Rapid advances in large language models (LLMs) have expanded their use across software engineering workflows, yet most prompt engineering remains ad hoc —yielding inconsistent quality, poor transferability, and inefficient iteration. This paper introduces and evaluates Preference-Driven Refinement (PDR), a structured prompt engineering method that iteratively updates prompts by incorporating user-selected preferred and non-preferred elements from model outputs. Building on in context learning, PDR uses synthetic example generation and explicit preference incorporation to overcome common challenges, such as instruction blindness, inadequate context capture, and alignment drift. We extend PDR with PDR+Critic, a multi-LLM refinement loop where a separate Critic model evaluates generated outputs, identifies strengths and weaknesses, and recommends improvements. To assess these structured refinement methods, we conduct a controlled, simulation-based study across five software engineering tasks and eight personas using GPT-5, with decoding parameters held constant to isolate methodological effects. To address evaluation circularity concerns, we employ multi-model cross-validation using independent LLM families (GPT-4o and Gemini-2.5-Pro) as evaluators Our results reveal both methodological contributions and challenges. PDR significantly reduces refinement iterations compared to ad hoc prompting (p = 0.020, FDR-corrected), demonstrating improved convergence efficiency through fewer refinement cycles. However, PDR exhibits longer total execution time due to structured processing overhead (Ad Hoc: 67.5s, PDR: 179.6s, PDR+Critic: 209.1s on average). PDR+Critic shows mixed effectiveness: while adding explicit evaluation loops, it often increases runtime and iteration count without consistent quality improvements, and both evaluators identified cases where critic feedback degraded output quality. Critically, multi-model evaluation revealed low inter-rater agreement (r = 0.044, p = 0.794) between independent evaluators, indicating that different LLM families apply fundamentally different quality standards. This finding weakens claims about quality improvements but contributes important evidence about current limitations in LLM-as-judge methodologies. Objective metrics (iteration counts, timing) remain valid and demonstrate PDR’s efficiency trade-offs: fewer iterations but longer execution time per iteration. By formalizing PDR and PDR+Critic, evaluating their performance with rigorous cross-model validation, and transparently reporting both successes and limitations, this paper advances systematic prompt engineering research. Our findings reveal key trade-offs between structure and efficiency, document how multi-LLM Generator–Critic loops interact with software engineering tasks, and motivate future work on standardized, reliable evaluation frameworks for LLM-augmented software development.

Spoof speech can be used to try and fool speaker verification systems that determine the identity of the speaker based on voice characteristics. This paper compares popular learnable front-ends on this task. We categorize the front-ends by defining two generic architectures and then analyze the filtering stages of both types in terms of learning constraints. We pro-pose replacing fixed filterbanks with a learnable layer that can better adapt to anti-spoofing tasks. The proposed FastAudio front-end is then tested with two popular back-ends to measure the performance on the Logical Access track of the ASVspoof 2019 dataset. The FastAudio front-end achieves a relative improvement of 29.7% when compared with fixed front-ends, outperforming all other learnable front-ends on this task.

An emerging trend in audio processing is capturing low-level speech representations from raw waveforms. These representations have shown promising results on a variety of tasks, such as speech recognition and speech separation. Compared to handcrafted features, learning speech features via backpropagation can potentially provide the model greater flexibility in how it represents data for different tasks. However, results from empirical studies show that, in some tasks, such as spoof speech detection, handcrafted features still currently outperform learned features. Instead of evaluating handcrafted features and raw waveforms independently, this paper proposes an Auxiliary Rawnet model to complement handcrafted features with features learned from raw waveforms for spoof speech detection. A key benefit of the approach is that it can improve accuracy at a relatively low computational cost. The proposed Auxiliary Rawnet model is tested using the ASVspoof 2019 dataset and pooled EER and min-tDCF are 1.11% and 0.03645 respectively. Results from this dataset indicate that a lightweight waveform encoder can boost the performance of handcrafted-features-based encoders for 10 types of spoof attacks, including 3 challenging attacks, in exchange for a small amount of additional computational work.

Research in the past several years has boosted the performance of automatic speaker verification systems and countermeasure systems to deliver low Equal Error Rates (EERs) on each system. However, research on joint optimization of both systems is still limited. The Spoofing-Aware Speaker Verification (SASV) 2022 challenge was proposed to encourage the development of integrated SASV systems with new metrics to evaluate joint model performance. This paper proposes an ensemble-free end-to-end solution, known as Spoof-Aggregated-SASV (SA-SASV) to build a SASV system with multi-task classifiers, which are optimized by multiple losses and has more flexible requirements in training set. The proposed system is trained on the ASVSpoof 2019 LA dataset, a spoof verification dataset with small number of bonafide speakers. Results of SASV-EER indicate that the model performance can be further improved by training in complete automatic speaker verification and countermeasure datasets.

This paper explores the translation of natural language into Bash Commands, which developers commonly use to accomplish command-line tasks in a terminal. In our approach a terminal takes a command as a sentence in plain English and translates it into the corresponding string of Bash Commands. The paper analyzes the performance of several architectures on this translation problem using the data from the NLC2CMD competition at the NeurIPS 2020 conference. The approach presented in this paper is the best performing architecture on this problem to date and improves the current state-of-the-art accuracy on this translation task from 13.8% to 53.2%.

Data visualization has become a vital tool to help people understand the driving forces behind real-world phenomena. Although the learning curve of visualization tools have been reduced, domain experts still often require significant amounts of training to use them effectively. To reduce this learning curve even further, this paper proposes Sketch2Vis, a novel solution using deep learning techniques and tools to generate the source code for multi-platform data visualizations automatically from hand-drawn sketches provided by domain experts, which is similar to how an expert might sketch on a cocktail napkin and ask a software engineer to implement the sketched visualization.This paper explores key challenges (such as model training) in generating visualization code from hand-drawn sketches since acquiring a large dataset of sketches paired with visualization source code is often prohibitively complicated. We present solutions for these problems and conduct experiments on three baseline models that demonstrate the feasibility of generating visualizations from hand-drawn sketches. The best models tested reach a structural accuracy of 95% in generating correct data visualization code from hand-drawn sketches of visualizations.

Summary form only given. The complete presentation was not made available for publication as part of the conference proceedings. This presentation will cover investments and advances in research needed to address these issues. In particular, I will discuss how the current notion of software development will be replaced by one where the software pipeline consists of AI and humans collaborating at scale on continuously evolving systems. These software-enabled systems will be even more pervasive than today, with levels of trust commensurate with the importance of the decisions they make. I will also discuss how software and humans need to become mutually trustworthy peers comprising socio-technical ecosystems, where human expressions of intent are reliably understood and socio-technical platforms enable collaboration at scale, leading to socially resilient, ethical, and unbiased behavior. Advances in compositional correctness and continuous reflection are also needed to allow intelligent systems to learn from experience and continuously improve.

Effective diabetes problem solving requires identification of risk factors for inadequate mealtime self-management. Ecological momentary assessment was used to enhance identification of factors hypothesized to impact self-management. Adolescents with type 1 diabetes participated in a feasibility trial for a mobile app called MyDay. Meals, mealtime insulin, self-monitored blood glucose, and psychosocial and contextual data were obtained for 30 days. Using 1472 assessments, mixed-effects between-subjects analyses showed that social context, location, and mealtime were associated with missed self-monitored blood glucose. Stress, energy, mood, and fatigue were associated with missed insulin. Within-subjects analyses indicated that all factors were associated with both self-management tasks. Intraclass correlations showed within-subjects accounted for the majority of variance. The ecological momentary assessment method provided specific targets for improving self-management problem solving, phenotyping, or integration within just-in-time adaptive interventions.

Mobile health (mHealth) apps have been adopted in healthcare areas such as the management of diabetes, the monitoring of physical activities and the treatment of HIV. The users of mHealth may be patients with handicaps such as motor impairments, difficulties to remember and psychiatric conditions. Hence, assumptions normally made on other types of apps, like the user's ability to type or remember a password, might not hold in the mHealth area. This paper evaluates how different authentication approaches impact mHealth apps usability. Second, we present new metrics to evaluate ease-of-use and third, we evaluate the usability of two common authentication approaches for mHealth apps via several key process aspects and their impact on users. Based on these results, we propose a QR-Code based authentication approach for mHealth apps, which helps overcome common impediments faced by mHealth apps users.

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.

Blockchain is a decentralized, trustless protocol that combines transparency, immutability, and consensus properties to enable secure, pseudo-anonymous transactions. Smart contracts are built atop a blockchain to support on-chain storage and enable Decentralized Apps (DApps) to interact with the blockchain programatically. Programmable blockchains have generated interest in the healthcare domain as a potential solution to resolve key challenges, such as gapped communications, inefficient clinical report delivery, and fragmented health records. This paper provides evaluation metrics to assess blockchain-based DApps in terms of their feasibility, intended capability, and compliance in the healthcare domain.

Large-scale cyber-physical systems (CPS) in mission-critical areas such as transportation, health care, energy, agriculture, defense, homeland security, and manufacturing, are becoming increasingly interconnected and interdependent. These types of CPS are unique in their need to combine rigorous control over timing and physical properties, as well as functional ones, while operating dynamically, reliably and affordably over significant scales of distribution, resource consumption, and utilization. As large-scale CPS continue to evolve-and grow in scale and complexity-they will impose significant and novel requirements for a new kind of cloud computing that is not supported by conventional technologies To meet these requirements, cloud computing advances are needed to establish real-time computing, communication, and control foundations rigorously at scale. Likewise, advances are needed to apply these foundations in a flexible and scalable manner to different real-world large-scale CPS challenge problems. To support both foundational and experimental R&D, a new generation of elastic infrastructure must be designed, developed, and evaluated. This paper identifies challenges, opportunities, and benefits for this work and for the largescale CPS it targets.

The articles in this special issue focus on the technology and applications supported by augmented reality.

SUMMARY Computing systems are increasingly designed as a collection of interacting services that constitute a set of functionality offered by a service provider or server to its clients. Many service‐oriented computing systems have constraints on the resources they allocate and manage. In these systems, certain types of services should consume resources only when they are accessed by clients, and clients should be shielded from where services are located, how they are deployed, and how their lifecycle is managed. The activator pattern provides an effective means to efficiently and transparently automate scalable on‐demand activation and deactivation of services accessed by many clients. This paper motivates the need for the activator pattern, describes the structure and dynamics of canonical implementations of the pattern, and examines the benefits and liabilities of applying this pattern to services in resource‐constrained computing systems. Copyright © 2011 John Wiley & Sons, Ltd.

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.

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.

SUMMARY SOA middleware has emerged as a powerful and popular distributed computing paradigm because of its high‐level abstractions for composing systems and encapsulating platform‐level details and complexities. Control of some details encapsulated by SOA middleware is necessary, however, to provide managed QoS for SOA systems that require predictable performance and behavior. This paper presents a policy‐driven approach for managing QoS in SOA systems called QoS enabled dissemination (QED). QED includes services for: (1) specifying and enforcing the QoS preferences of individual clients; (2) mediating and aggregating QoS management on behalf of competing users; and (3) shaping information exchange to improve real‐time performance. We describe QED's QoS services and mechanisms in the context of managing QoS for a set of Publish‐Subscribe‐Query information management services. These services provide a representative case study in which CPU and network bottlenecks can occur, client QoS preferences can conflict, and system‐level QoS requirements are based on higher level, aggregate end‐to‐end goals. We also discuss the design of several key QoS services and describe how QED's policy‐driven approach bridges users to the underlying middleware and enables QoS control based on rich and meaningful context descriptions, including users, data types, client preferences, and information characteristics. In addition, we present experimental results that quantify the improved control, differentiation, and client‐level QoS enabled by QED. Copyright © 2011 John Wiley & Sons, Ltd.

Distributed real-time and embedded (DRE) systems can be composed of hundreds of software components running across tens or hundreds of networked processors that are physically separated from one another. A key concern in DRE systems is determining the spatial deployment topology, which is how the software components map to the underlying hardware components. Optimizations, such as placing software components with high-frequency communications on processors that are closer together, can yield a number of important benefits, such as reduced power consumption due to decreased wireless transmission power required to communicate between the processing nodes. Determining a spatial deployment plan across a series of processors that will minimize power consumption is hard since the spatial deployment plan must respect a combination of real-time scheduling, fault-tolerance, resource, and other complex constraints. This article presents a hybrid heuristic/evolutionary algorithm, called ScatterD, for automatically generating spatial deployment plans that minimize power consumption. This work provides the following contributions to the study of spatial deployment optimization for power consumption minimization: (1) it combines heuristic bin-packing with an evolutionary algorithm to produce a hybrid algorithm with excellent deployment derivation capabilities and scalability, (2) it shows how a unique representation of the spatial deployment solution space integrates the heuristic and evolutionary algorithms, and (3) it analyzes the results of experiments performed with data derived from a large-scale avionics system that compares ScatterD with other automated deployment techniques. These results show that ScatterD reduces power consumption by between 6% and 240% more than standard bin-packing, genetic, and particle swarm optimization algorithms.

Performance analysis tools for enterprise distributed real-time and embedded (DRE) systems require instrumenting heterogeneous sources (such as application- and system-level hardware and software resources). Traditional techniques for software instrumentation of such systems, however, are tightly coupled to system design and metrics of interest. It is therefore hard for system testers to increase their knowledge base and analytical capabilities for enterprise DRE system performance using existing instrumentation techniques when metrics of interest are not known during initial system design. This paper provides two contributions to research on software instrumentation for enterprise DRE systems. First, it presents OASIS, which is service-oriented middleware for instrumenting enterprise DRE systems to collect and extract metrics without design time knowledge of which metrics are collected. Second, this paper empirically evaluates OASIS in the context of a representative enterprise DRE system from the domain of shipboard computing. Results from applying OASIS to a representative enterprise DRE system show that its flexibility enables DRE system testers to precisely control the overhead incurred via instrumentation.

Service-oriented architecture (SOA) middleware has emerged as a powerful and popular distributed computing paradigm due to its high-level abstractions for composing systems and hiding platform-level details. Control of some details hidden by SOA middleware is necessary, however, to provide managed quality of service (QoS) for SOA systems that need predictable performance and behavior. This paper presents a policy-driven approach for managing QoS in SOA systems. We discuss the design of several key QoS services and empirically evaluate their ability to provide QoS under CPU overload and bandwidth-constrained situations.

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.

Search-based software engineering is an emerging paradigm that uses automated search algorithms to help designers iteratively find solutions to complicated design problems. For example, when designing a climate monitoring satellite, designers may want to use the minimal amount of computing hardware to reduce weight and cost while supporting the image processing algorithms running onboard. A key problem in these situations is that the hardware and software designs are locked in a tightly coupled cost-constrained producer/consumer relationship that makes it hard to find a good hardware/software design configuration. Search-based software engineering can be used to apply algorithmic techniques to automate the search for hardware/software designs that maximize the image processing accuracy while respecting cost constraints. This paper provides the following contributions to research on search-based software engineering: 1) We show how a cost-constrained producer/consumer problem can be modeled as a set of two multidimensional multiple-choice knapsack problems (MMKPs), 2) we present a polynomial-time search-based software engineering technique, called the Allocation-baSed Configuration Exploration Technique (ASCENT), for finding near optimal hardware/software codesign solutions, and 3) we present empirical results showing that ASCENT's solutions average over 95 percent of the optimal solution's value.

Unit testing component-based distributed systems traditionally involves testing functional concerns of the application logic throughout the software lifecycle. In contrast, testing non-functional distributed system concerns (e.g., end-to-end response time, security, and reliability) typically does not occur until system integration because it requires a complete system to perform such tests, as well as sophisticated techniques to identify and analyze performance metrics that constitute non-functional concerns. Unit testing non-functional concerns is even harder in an agile development environment, due to the disconnect between high-level system specification and low-level performance metrics. This paper describes a methodology and tool called Understanding Non-functional Intentions via Testing and Experimentation (UNITE). UNITE is designed to unit test non-functional concerns of three component-based distributed systems. The results from applying UNITE to a component-based distributed system show how it simplifies unit testing and evaluation of non-functional properties during the early stages of the software lifecycle.

Sensor webs are often composed of servers connected to distributed real-time embedded (DRE) systems that operate in open environments where operating conditions, workload, resource availability, and connectivity cannot be accurately characterized a priori. The South East Alaska MOnitoring Network for Science, Telecommunications, Education, and Research (SEAMONSTER) project exhibits many common system management and dynamic operation challenges for effective, autonomous system adaptation in a representative sensor web. These challenges cover both field operation (e.g., power management through system sleep/wake cycles and reaction to local environmental changes) and server operation (e.g., system adaptation for new/modified goals, resource allocation for a changing set of applications, and configuration changes for fluctuating workload). This paper presents the results of integrating and applying quality-of-service (QoS)-enabled component middleware, dynamic resource management, and autonomous agent technologies to address these challenges in SEAMONSTER.

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.

Soft real-time systems sometimes operate under uncertain and unpredictable environmental conditions which makes event arrival times unreliable and variable. Input to such systems also change from time to time making event processing times variable. Due to such variations, traditional techniques using worst case times to estimate system performance deviate far from actual expected behavior.This paper presents a Method of Stages based Analysis of soft Real Time systems (MoSART). MoSART takes into account variance in both the arrival and execution time and can model the performance of different scheduling algorithms. Sensitivity analysis, experimental validation, and the discovery of state dependent algorithms that outperform popular algorithms are demonstrated.

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.

Real-time and embedded systems have traditionally been designed for closed environments where operating conditions, input workloads, and resource availability are known a priori and are subject to little or no change at runtime. There is an increasing demand, however, for autonomous capabilities in open distributed real-time and embedded (DRE) systems that execute in environments where input workload and resource availability cannot be accurately characterized a priori. These systems can benefit from autonomic computing capabilities, such as self-(re)configuration and self-optimization, that enable autonomous adaptation under varying—even unpredictable—operational conditions. A challenging problem faced by researchers and developers in enabling autonomic computing capabilities to open DRE systems involves devising adaptive planning and resource management strategies that can meet mission objectives and end-to-end quality of service (QoS) requirements of applications. To address this challenge, this paper presents the Integrated Planning, Allocation, and Control (IPAC) framework, which provides decision-theoretic planning, dynamic resource allocation, and runtime system control to provide coordinated system adaptation and enable the autonomous operation of open DRE systems. This paper presents two contributions to research on autonomic computing for open DRE systems. First, we describe the design of IPAC and show how IPAC resolves the challenges associated with the autonomous operation of a representative open DRE system case study. Second, we empirically evaluate the planning and adaptive resource management capabilities of IPAC in the context of our case study. Our experimental results demonstrate that IPAC enables the autonomous operation of open DRE systems by performing adaptive planning and management of system resources.

Software is increasingly deployed in vehicles as demand for new functionality increases and cheaper and more powerful hardware becomes available. Likewise, emerging wireless communication protocols allow the integration of new software into vehicles, thereby enabling time-bounded adaptive response to changes that occur in mobile environments. Examples of time-bounded adaptation include adaptive cruise control and the dynamic integration of location-aware services within fixed time bounds.

An important class of new and existing applications requires cooperating entities to share and exchange information seamlessly in real-time, while meeting stringent requirements for quality of service (QoS) and heterogeneity. This paper describes how the recently adopted OMG DDS standard, and the OpenSplice DDS implementation of this standard, support the data distribution and management challenges posed by next-generation distributed systems, and systems of 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.

Effective resource management for distributed real-time embedded (DRE) systems is hard due to their unique characteristics, including (1) constraints in multiple resources and (2) highly fluctuating resource availability and input workload. DRE systems can benefit from a middleware framework that enables adaptive resource management algorithms to ensure application QoS requirements are met. This paper identifies key challenges in designing and extending resource allocation algorithms for DRE systems. We present an empirical study of bin-packing algorithms enhanced to meet these challenges. Our analysis identifies input application patterns that help generate appropriate heuristics for using these algorithms effectively in DRE systems.

This paper provides four contributions to the study of optimization techniques for component-based distributed real-time and embedded (DRE) systems. First, we describe key challenges of designing component-based DRE systems and identify key sources of overhead in a typical component-based DRE system from the domain of shipboard computing. Second, we describe a class of optimization techniques applicable to the deployment of component-based DRE systems. Third, we describe the physical assembly mapper (PAM), which is a model-driven optimization tool that implements these techniques to reduce footprint. Fourth, we evaluate the benefits of these optimization techniques empirically and analyze the results. Our results indicate that the deployment-time optimization techniques in PAM provides significant benefits, such as 45% improvement in footprint, when compared to conventional component middleware technologies.

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.

Feature models are widely used to model software product-line (SPL) variability. SPL variants are configured by selecting feature sets that satisfy feature model constraints. Configuration of large feature models can involve multiple stages and participants, which makes it hard to avoid conflicts and errors. New techniques are therefore needed to debug invalid configurations and derive the minimal set of changes to fix flawed configurations. This paper provides three contributions to debugging feature model configurations: (1) we present a technique for transforming a flawed feature model configuration into a Constraint Satisfaction Problem (CSP) and show how a constraint solver can derive the minimal set of feature selection changes to fix an invalid configuration, (2) we show how this diagnosis CSP can automatically resolve conflicts between configuration participant decisions, and (3) we present experiment results that evaluate our technique. These results show that our technique scales to models with over 5,000 features, which is well beyond the size used to validate other automated techniques.

The decentralized process of configuring enterprise applications is complex and error-prone, involving multiple participants/roles and numerous configuration changes across multiple files, application server settings, and database decisions. This paper describes an approach to automated enterprise application configuration that uses a feature model, executes a series of probes to verify configuration properties, formalizes feature selection as a constraint satisfaction problem, and applies constraint logic programming techniques to derive a correct application configuration. To validate the approach, we developed a configuration engine, called Fresh, for enterprise Java applications and conducted experiments to measure how effectively Fresh can configure the canonical Java Pet Store application. Our results show that Fresh reduces the number of lines of hand written XML code by up to 92% and the total number of configuration steps by up to 72%.

Distributed real-time embedded (DRE) systems perform sequences of coordination and heterogeneous data manipulation tasks in dynamic environments to meet specified goals. Autonomous operation of DRE systems can benefit from the integrated operation of (1) a decision-theoretic spreading activation partial order planner (SA-POP) that combines task planning and scheduling in uncertain environments with (2) a resource allocation and control engine (RACE) middleware framework that integrates multiple resource management algorithms for (re)deploying and (re)configuring task sequence components in these systems. This paper demonstrates the effectiveness of SA-POP and RACE in managing and executing mission goals for a multisatellite application. Our results show that combining planning, scheduling and resource constraints dynamically is the key to implementing autonomy in 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

Standards-based quality of service (QoS)-enabled component middleware is increasingly being used as a platform for developing distributed real-time embedded (DRE) systems that execute in open environments where operational conditions, input workload, and resource availability cannot be characterized accurately a priori. Although QoS-enabled component middleware offers many desirable features, until recently it lacked the ability to efficiently allocate resources and configure platform-specific QoS settings based on utilization of system resources and application QoS. Moreover, it has also lacked the ability to monitor and enforce application QoS requirements. This paper presents two contributions to research on adaptive resource management for component-based DRE systems. First, we describe the structure and functionality of the Resource Allocation and Control Engine (RACE), which is an open-source adaptive resource management framework built atop standards-based QoS-enabled component middleware. Second, we demonstrate the effectiveness of RACE in the context of a representative DRE system: NASA's Magnetospheric Multi-scale Mission system.

The dynamic nature of mobile ad hoc networks poses fundamental challenges to the design of service composition schemes that can minimize the effect of service disruptions. Although improving reliability has been a topic of extensive research in mobile ad hoc networks, little work has considered service deliveries spanning multiple components. Moreover, service composition strategies proposed for wireline networks are poorly suited for wireless ad hoc networks due to their highly dynamic nature. This paper proposes a new service composition and recovery framework designed to achieve minimum service disruptions for mobile ad hoc networks. The framework consists of two-tiers: service routing, which selects the service components, and network routing, which finds the network path that connects these service components. Our framework is based on the disruption index, which is a novel construct that characterizes different aspects of service disruptions, including frequency and duration. For ad hoc networks with known mobility plan, we formulate the problem of minimum-disruption service composition and recovery (MDSCR) as a dynamic programming problem and give its optimal solution. Based on the derived analytical insights, we present our MDSCR heuristic algorithm for ad hoc networks with uncertain node mobility. This heuristic algorithm approximates the optimal solution with one-step lookahead prediction, where service link lifetime is predicted using linear regression. We evaluate the performance of our algorithm via simulation study conducted under various network environments.

Product-line architectures (PLAs) designed for mobile devices create a unique challenge for automated product variant selection engines since variants must be derived on-the-fly as devices are discovered. Current automation techniques do not incorporate device resource consumption constraints into variant selection and do not address how a PLA can be designed to improve automated variant selection speed. This paper presents a tool called Scatter whose input is (1) the requirements of PLA construction and (2) the resources available on a discovered mobile device and whose output is the optimal variant that can be deployed to the device. Scatter provides automatic variant selection based on configuration and resource constraints and also ensures that variant selection is optimal with regard to a configurable cost function. The paper presents our results from experiments with Scatter and how PLA design decisions affect a constraint-based variant selection engine's solving speed.

Software engineers increasingly emphasize agility and flexibility in their designs and development approaches. They increasingly use distributed development teams, rely on component assembly and deployment rather than green field code writing, rapidly evolve the system through incremental development and frequent updating, and use flexible product designs supporting extensive end-user customization. While agility and flexibility have many benefits, they also create an enormous number of potential system configurations built from rapidly changing component implementations. Since today's quality assurance (QA) techniques do not scale to handle highly configurable systems, we are developing and validating novel software QA processes and tools that leverage the extensive computing resources of user and developer communities in a distributed, continuous manner to improve software quality significantly. This paper provides several contributions to the study of distributed, continuous QA (DCQA). First, it shows the structure and functionality of Skoll, which is an environment that defines a generic around-the-world, around-the-clock QA process and several sophisticated tools that support this process. Second, it describes several novel QA processes built using the Skoll environment. Third, it presents two studies using Skoll: one involving user testing of the Mozilla browser and another involving continuous build, integration, and testing of the ACE+TAO communication software package. The results of our studies suggest that the Skoll environment can manage and control distributed continuous QA processes more effectively than conventional QA processes. For example, our DCQA processes rapidly identified problems that had taken the ACE+TAO developers much longer to find and several of which they had not found. Moreover, the automatic analysis of QA results provided developers information that enabled them to quickly find the root causes of problems

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

There is an increasing demand to introduce adaptive capabilities in distributed real-time and embedded (DRE) systems that execute in open environments where system operational conditions, input workload, and resource availability cannot be characterized accurately a priori. To meet these needs, this paper presents the hierarchical distributed resource-management architecture (HiDRA), which provides adaptive resource management using control-the ore tic techniques that adapt to workload fluctuations and resource availability. In contrast to adaptive control techniques that manage only one type of system resource, HiDRA features a hierarchical control scheme that manages both bandwidth and processor utilization simultaneously. This paper presents three contributions to research in adaptive resource management for DRE systems. First, we describe the structure and functionality of HiDRA. Second, we present an analytical model of HiDRA that formalizes its control theoretic behavior and present analytical performance guarantees. Third, we evaluate the performance of HiDRA via experiments on a representative DRE system that performs distributed target tracking in real-time. Our analytical and empirical results indicate that HiDRA yields predictable, stable, and high system performance, even in the face of changing workload.

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.

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.

Component middleware is popular for enterprise distributed systems because it provides effective reuse of the core intellectual property (i.e., the "business logic"). Component-based enterprise distributed real-time and embedded (DRE) systems, however, incur new integration problems associated with component configuration and deployment. New research is therefore needed to minimize the gap between the development and deployment/configuration of components, so that deployment and configuration strategies can be evaluated well before system integration. This paper uses an industrial case study from the domain of shipboard computing to show how system execution modeling tools can provide software and system engineers with quantitative estimates of system bottlenecks and performance characteristics to help evaluate the performance of component-based enterprise DRE systems and reduce time/effort in the integration phase. The results from our case study show the benefits of system execution modeling tools and pinpoint where more work is needed

Abstract Computing systems are increasingly distributed, real‐time, and embedded (DRE) and must operate under highly unpredictable and changeable conditions. A challenging problem for DRE systems is adaptation of behavior and reconfiguration of resources to maintain the best application performance in the face of changes in system load and available resources. To provide predictable mission‐critical quality of service (QoS) end‐to‐end, QoS‐enabled middleware services and mechanisms have begun to emerge, but they lack support for applications with stringent QoS requirements in changing, dynamic environments. This paper presents two contributions to research on adaptive and reconfigurable DRE systems. First, we describe the structure and functionality of an advanced middleware platform for developing applications that apply various techniques to adapt themselves to changes in resource availability to meet real‐time QoS requirements. Second, we present results of a case study of a multimedia application for Unmanned Aerial Vehicle (UAV) video distribution we developed using this middleware platform in conjunction with QoS‐enabledoperating systems and networking protocols. We describe the design of the multimedia application using our middleware platform and report empirical results showing how adaptive behavior and end‐to‐end resource management techniques are used to reconfigure the system dynamically to meet timeliness requirements. Copyright © 2006 John Wiley & Sons, Ltd.

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.

End-to-end middleware predictability is essential to support quality of service (QoS) capabilities needed by distributed real-time and embedded (DRE) applications. Real-time CORBA is a middleware standard that allows DRE applications to allocate, schedule, and control the QoS of CPU, memory, and networking resources. Existing real-time CORBA solutions are implemented in C++, which is generally more complicated and error-prone to program than Java. The real-time specification for Java (RTSJ) provides extensions that enable Java to be used for developing DRE systems. Real-time CORBA does not currently leverage key RTSJ features, such as scoped memory and real-time threads. Thus, integration of real-time CORBA and RTSJ is essential to ensure the predictability required for Java-based DRE applications. We provide the following contributions to the study of middleware for DRE applications. First we analyze the architecture of ZEN, our implementation of real-time CORBA, identifying sources for the application of RTSJ features. Second, we describe how RTSJ features, such as scoped memory and real-time threads, can be associated with key ORB components to enhance the predictability of DRE applications using realtime CORBA and the RTSJ. Third, we perform preliminary qualitative and quantitative analysis of predictability enhancements arising from our application of RTSJ features. Our results show that use of RTSJ features can considerably improve the predictability of DRE applications written using Real-time CORBA and real-time Java.

Quality assurance (QA) tasks, such as testing, profiling, and performance evaluation, have historically been done in-house on developer-generated workloads and regression suites. Since this approach is inadequate for many systems, tools and processes are being developed to improve software quality by increasing user participation in the QA process. A limitation of these approaches is that they focus on isolated mechanisms, not on the coordination and control policies and tools needed to make the global QA process efficient, effective, and scalable. To address these issues, we have initiated the Skoll project, which is developing and validating novel software QA processes and tools that leverage the extensive computing resources of worldwide user communities in a distributed, continuous manner to significantly and rapidly improve software quality. This paper provides several contributions to the study of distributed continuous QA. First, it illustrates the structure and functionality of a generic around-the-world, around-the-clock QA process and describes several sophisticated tools that support this process. Second, it describes several QA scenarios built using these tools and process. Finally, it presents a feasibility study applying these scenarios to a 1MLOC+ software package called ACE+TAO. While much work remains to be done, the study suggests that the Skoll process and tools effectively manage and control distributed, continuous QA processes. Using Skoll we rapidly identified problems that had taken the ACE+TAO developers substantially longer to find and several of which had previously not been found. Moreover, automatic analysis of QA task results often provided developers information that quickly led them to the root cause of the problems.

Distributed real-time and embedded (DRE) systems in which application requirements and environmental conditions may not be known a priori-or which may vary at run-time-can benefit from an adaptive approach to management of quality-of-service (QoS) to meet key constraints, such as end-to-end timeliness. Moreover, coordinated management of multiple QoS capabilities across multiple layers of applications and their supporting middleware can help to achieve necessary assurances of meeting these constraints. We offer two contributions to the study of adaptive DRE computing systems: (1) a case study of our integration of multiple middleware QoS management technologies to manage quality and timeliness of imagery adoptively within a representative DRE avionics system and (2) empirical results and analysis of the impact of that integration on key tradeoffs between timeliness and image quality in that system.

Many distributed real-time and embedded (DRE) applications require a scalable event-driven communication model that decouples suppliers from consumers and simultaneously supports advanced quality of service (QoS) properties and event filtering mechanisms. The CORBA notification service provides publisher/subscriber capabilities designed to support scalable event-driven communication by routing events efficiently between suppliers and consumers, enforcing QoS properties (such as reliability, priority, ordering, and timeliness), and filtering events at multiple points in a distributed system. The standard CORBA notification service is insufficient, however, to enforce predictable communication needed by DRE applications and does not leverage real-time CORBA capabilities, such as end-to-end priority assignment or scheduling services. We make three contributions to the study of scalable real-time notification services for DRE applications. First, we describe the requirements of the OMG request for proposals (RFP) on real-time notification, which seeks solutions to the problem of enforcing real-time properties by enhancing the standard CORBA notification service. Second, we explain how we have addressed key design challenges faced when implementing a real-time notification service for TAO, which is our CORBA-compliant real-time object request broker (ORB). We discuss how we integrate real-time CORBA features (such as thread pools, thread lanes, and priority models) to provide real-time event communication. Finally, we analyze the results of empirical benchmarks of the performance and predictability of TAO's real-time notification service. These results show that the static real-time assurances provided by real-time CORBA are maintained within the more flexible context of TAO's real-time notification service.

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.

In an emerging class of open distributed real-time and embedded (DRE) systems with stringent but dynamic QoS requirements, there is a need to propagate QoS parameters and enforce task QoS requirements across multiple endsystems in a way that is simultaneously efficient and adaptable. The object management group's (OMG) real-time CORBA 2.0 specification (RTC2) defines a dynamic scheduling framework for propagating and enforcing QoS parameters dynamically in standard CORBA middleware. We make two contributions to research on middleware for open DRE systems. First, it describes the design and capabilities of the RTC2 dynamic scheduling framework provided by TAO, which is our open-source CORBA standards-based object request broker (ORB). Second, it describes and summarize the results of empirical studies we have conducted to validate our RTC2 framework in the context of open DRE systems. The results of those experiments show that a range of policies for adaptive scheduling and management of distributable threads can be enforced efficiently in standard middleware for open DRE systems.

This tutorial describes how to apply patterns and middleware frameworks to alleviate the complexity of developing software for distributed systems. These patterns and framework components have been used successfully by the presenter on production communication software projects at many commercial companies for telecommunication systems, network management for personal communication systems, electronic medical imaging systems, real-time avionics and aerospace systems, distributed interactive simulations, and automated stock trading.

The knowledge required to develop complex software has historically existed in programming folklore, the heads of experienced developers, or buried deep in the code. These locations are not ideal since the effort required to capture and evolve this knowledge is expensive, time-consuming, and error-prone. Many popular software modeling methods and tools address certain aspects of these problems by documenting how a system is designed However they only support limited portions of software development and do not articulate why a system is designed in a particular way, which complicates subsequent software reuse and evolution. Patterns, frameworks, and middleware are increasingly popular techniques for addressing key aspects of the challenges outlined above. Patterns codify reusable design expertise that provides time-proven solutions to commonly occurring software problems that arise in particular contexts and domains. Frameworks provide both a reusable product-line architecture [1] - guided by patterns - for a family of related applications and an integrated set of collaborating components that implement concrete realizations of the architecture. Middleware is reusable software that leverages patterns and frameworks to bridge the gap between the functional requirements of applications and the underlying operating systems, network protocol stacks, and databases. This paper presents an overview of patterns, frameworks, and middleware, describes how these technologies complement each other to enhance reuse and productivity, and then illustrates how they have been applied successfully in practice to improve the reusability and quality of complex software systems.

Increasingly complex requirements, coupled with tighter economic and organizational constraints, are making it hard to build complex distributed real-time embedded (DRE) systems entirely from scratch. Therefore, the proportion of DRE systems made up of commercial-off-the-shelf (COTS) hardware and software is increasing significantly. There are relatively few systematic empirical studies, however, that illustrate how suitable COTS-based hardware and software have become for mission-critical DRE systems. This paper provides the following contributions to the study of real-time quality-of-service (QoS) assurance and performance in COTS-based DRE systems: it presents evidence that flexible configuration of COTS middleware mechanisms, and the operating system (OS) settings they use, allows DRE systems to meet critical QoS requirements over a wider range of load and jitter conditions than statically configured systems; it shows that in addition to making critical QoS assurances, noncritical QoS performance can be improved through flexible support for alternative scheduling strategies; and it presents an empirical study of three canonical scheduling strategies; specifically the conditions that predict success of a strategy for a production-quality DRE avionics mission computing system. Our results show that applying a flexible scheduling framework to COTS hardware, OSs, and middleware improves real-time QoS assurance and performance for mission-critical DRE systems.

End-to-end predictability of remote operations is essential for many fixed-priority distributed real-time and embedded (DRE) applications, such as command and control systems, manufacturing process control systems, large-scale distributed interactive simulations, and testbeam data acquisition systems. To enhance predictability, the Real-time CORBA specification defines standard middleware features that allow applications to allocate, schedule, and control key CPU, memory, and networking resources necessary to ensure end-to-end quality of service support. This paper provides two contributions to the study of Real-time CORBA middleware for DRE applications. First, we identify potential problems with ensuring predictable behavior in conventional middleware by examining the end-to-end critical code path of a remote invocation and identifying sources of unbounded priority inversions. Experimental results then illustrate how the problems we identify can yield unpredictable behavior in conventional middleware platforms. Second, we present design techniques for ensuring real-time quality of service in middleware. We show how middleware can be redesigned to use nonmultiplexed resources to eliminate sources of unbounded priority inversion. The empirical results in this paper are conducted using TAO, which is widely used and open-source DRE middleware compliant with the Real-time CORBA specification.

More than 90 percent of all microprocessors are now used for real-time and embedded applications. The behavior of these applications is often constrained by the physical world. It is therefore important to devise higher-level languages and middleware that meet conventional functional requirements, as well as dependably and productively enforce real-time constraints. We provide two contributions to the study of languages and middleware for real-time and embedded applications. We first describe the architecture of jRate, which is an open-source ahead-of-time-compiled implementation of the RTSJ middleware. We then show performance results obtained using RTJPerf, which is an open-source benchmarking suite that systematically compares the performance of RTSJ middleware implementations. We show that, while research remains to be done to make RTSJ a bullet-proof technology, the initial results are promising. The performance and predictability of JRate provides a baseline for what can be achieved by using ahead-of-time compilation. Likewise, RTJPerf enables researchers and practitioners to evaluate the pros and cons of RTSJ middleware systematically as implementations mature.

Abstract To be an effective platform for performance‐sensitive real‐time systems, commodity‐off‐the‐shelf (COTS) distributed object computing (DOC) middleware must support application quality of service (QoS) requirements end‐to‐end. However, conventional COTS DOC middleware does not provide this support, which makes it unsuited for applications with stringent latency, determinism, and priority preservation requirements. It is essential, therefore, to develop standards‐based, COTS DOC middleware that permits the specification, allocation, and enforcement of application QoS requirements end‐to‐end. The real‐time CORBA and messaging specifications in the CORBA 2.4 standard are important steps towards defining standards‐based, COTS DOC middleware that can deliver end‐to‐end QoS support at multiple levels in distributed and embedded real‐time systems. These specifications still lack sufficient detail, however, to portably configure and control processor, communication, and memory resources for applications with stringent QoS requirements. This paper provides four contributions to research on real‐time DOC middleware. First, we illustrate how the CORBA 2.4 real‐time and messaging specifications provide a starting point to address the needs of an important class of applications with stringent real‐time requirements. Second, we illustrate how the CORBA 2.4 specifications are not sufficient to solve all the issues within this application domain. Third, we describe how we have implemented portions of these specifications, as well as several enhancements, using TAO, which is our open‐source real‐time CORBA ORB. Finally, we evaluate the performance of TAO empirically to illustrate how its features address the QoS requirements for certain classes of real‐time applications. Copyright © 2001 John Wiley & Sons, Ltd.

Although existing CORBA specifications, such as Real-time CORBA and CORBA Messaging, address many end-to-end quality of service (QoS) properties, they do not define strategies for configuring these properties into applications flexibly, transparently, and adaptively. Therefore, application developers must make these configuration decisions manually and explicitly which is tedious, error-prone, and often suboptimal. Although the recently adopted CORBA Component Model (CCM) does define a standard configuration framework for packaging and deploying software components, conventional CCM implementations focus on functionality rather than adaptive quality of service, which makes them unsuitable for next generation applications with demanding QoS requirements. The paper presents three contributions to the study of middleware for QoS-enabled component based applications. It outlines reflective middleware techniques designed to adaptively: (1) select optimal communication mechanisms; (2) manage QoS properties of CORBA components in their containers; and (3) (re)configure selected component executors dynamically. Based on our ongoing research on CORBA and the CCM, we believe the application of reflective techniques to component middleware will provide a dynamically adaptive and (re)configurable framework for COTS software that is well-suited for the QoS demands of next generation applications.

In many application domains, the distributed object computing (DOC) middleware is responsible for dispatching upcalls to one or more application objects when events or requests arrive from clients. Implementing efficient, predictable, and scalable middleware dispatching mechanisms is hard and implementing them for multi-threaded systems is even harder. In particular dispatching mechanisms must be prepared to dispatch upcalls to multiple objects, to handle recursive requests originated from application-provided upcalls, and must often collaborate with the application to control object life-cycle. In our DOC middleware research we have implemented many dispatching mechanisms that repeatedly apply common solutions to solve the challenges outlined above. Moreover, we have discovered that the forces constraining dispatching mechanisms often differ slightly thereby requiring alternative solutions. This paper presents two contributions to the design and implementation of efficient, predictable, scalable and flexible DOC middleware and applications. First, it shows how patterns can be applied to the object-oriented systems to capture key design and performance characteristics of proven dispatching mechanisms. Second it presents a pattern language that describes successful solutions that are appropriate for key dispatching challenges that arise in various real-time DOC middleware and 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.

ndessaig 63 ireste.

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.

High-performance Web servers are essential to meet the growing demands of the Internet and large-scale intranets. Satisfying these demands requires a thorough understanding of key factors affecting Web server performance. This paper presents empirical analysis illustrating how dynamic and static adaptivity can enhance Web server performance. Two research contributions support this conclusion. First, the paper presents results from a comprehensive empirical study of Web servers (such as Apache, Netscape Enterprise, PHTTPD, Zeus, and JAWS) over high-speed ATM networks. This study illustrates their relative performance and precisely pinpoints the server design choices that cause performance bottlenecks. Once network and disk I/O overheads are reduced to negligible constant factors, the main determinants of Web server performance are its protocol processing path and concurrency strategy. Moreover no single strategy performs optimally for all load conditions and traffic types. Second, we describe the design techniques and optimizations used to develop JAWS, our high-performance adaptive Web server. JAWS is an object-oriented Web server that was explicitly designed to alleviate the performance bottlenecks we identified in existing Web servers. The performance optimizations used in JAWS include adaptive prespawned threading, fixed headers, cached date processing, and file caching. In addition, JAWS uses a novel software architecture that substantially improves its portability and flexibility, relative to other Web servers.

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.

The CORBA Event Service provides a flexible model for asynchronous communication among objects. However, the standard CORBA Event Service specification lacks important features required by real-time applications. For instance, operational flight programs for fighter aircraft have complex real-time processing requirements. This paper describes the design and performance of an object-oriented, real-time implementation of the GORBA Event Service that is designed to meet these requirements.This paper makes three contributions to the design and performance measurement of object-oriented real-time systems. First, it illustrates how to extend the CORBA Event Service so that it is suitable for real-time systems. These extensions support periodic rate-based event processing and efficient event filtering and correlation. Second, it describes how to develop object-oriented event dispatching and scheduling mechanisms that can provide real-time guarantees. Finally, the paper presents benchmarks that demonstrate the performance tradeoffs of alternative concurrent dispatching mechanisms for real-time Event Services.

In the realm of OO methodologies there are two major schools of thought. Both schools claim to define mechanisms whereby software applications can be created that are reusable, maintainable, and robust. Moreover, both schools claim to use abstraction as a key mechanism for achieving these benefits. At issue is whether or not these two schools are fundamentally different, or just variations on an object-oriented theme.Shlaer and Mellor have dubbed one of these schools Translational. In the translational approach, two models are created. One is an abstract model of the application domain which is devoid of any design dependencies. The other model is an abstract model of the design which is devoid of any application dependencies. These two models are composed automatically to yield the code for the system.The other school - supported by Booch, Rumbaugh, Jacobson, and Martin - views the architecture of a system from several different perspectives of abstraction, e.g. logical, physical. These abstractions typically form a layer; abstractions in the logical sense manifest themselves as individual classes as well as collaborations of classes. There may be one layered model, at different layers of abstraction, or, especially given the Objectory view point, there may be multiple models, with an analysis model that's nearly independent from the design model.The panel will explore:• Is there a seamless transition between analysis and design?• Should there be a single model or should there be two - one for the analysis and one for the design?• If there are two models, how are they bridged?• What, if any, are the differences in process between the two schools?• How does architecture manifest itself!• Is there, in fact, a real difference between the two schools of thought?As a result of this exploration, we hope to answer the question: Is translation a myth or is it a reality?

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.

This paper describes research on new methods and architectures that enable the synergistic combination of IP and ATM technologies. We have designed a highly scalable gigabit IP router based on an ATM core and a set of tightly coupled general-purpose processors. This aItPm (pronounced "IP on ATM" or, if you prefer, "ip-attem") architecture provides flexibility in congestion control, routing, resource management, and packet scheduling.The aItPm architecture is designed to allow experimentation with, and fine tuning of, the protocols and algorithms that are expected to form the core of the next generation IP in the context of a gigabit environment. The underlying multi-CPU embedded system will ensure that there are enough CPU and memory cycles to perform all IP packet processing at gigabit rates. We believe that the aItPm architecture will not only lead to a scalable high-performance gigabit IP router technology, but will also demonstrate that IP and ATM technologies can be mutually supportive.

This paper describes SS7 error monitor characteristics, discusses the existing SUERM (signal unit error rate monitor), and develops the recently proposed EIM (error interval monitor) for higher speed SS7 links. A SS7 error monitor is considered safe if it ensures acceptable link quality and is considered effective if it is tolerant to short-term phenomena. Formal criteria for safe and effective error monitors are formulated. This paper develops models of changeover transients, the unstable component of queue length resulting from errors. These models are in the form of recursive digital filters. Time is divided into sequential intervals. The filter's input is the number of errors which have occurred in each interval. The output is the corresponding change in transmit queue length. Engineered EIMs are constructed by comparing an estimated changeover transient with a threshold T using a transient model modified to enforce SS7 standards. When this estimate exceeds T, a changeover will be initiated and the link will be removed from service. EIMs can be differentiated from SUERM by the fact that EIMs monitor errors over an interval while SUERMs count errored messages. EIM offer several advantages over SUERMs, including the fact that they are safe and effective, impose uniform standards in link quality, are easily implemented, and make minimal use of real-time resources. >

A framework containing a number of resources, languages, and tools for generating customized protocols that support diverse multimedia applications running on high-performance networks is described. The framework facilitates the configuration of application-tailored, function-based communication protocols that are automatically synthesized from high-level specifications.

Abstract Computer communication systems must undergo significant changes to keep pace with the increasingly demanding and diverse multimedia applications that will run on the next generation of high‐performance networks. To facilitate these changes, we are developing A Dynamically Assembled Protocol Transformation, Integration and evaluation Environment (ADAPTIVE). ADAPTIVE provides an integrated environment for developing and experimenting with flexible transport system architectures that support lightweight and adaptive communication protocols for diverse multimedia applications running on high‐performance networks. Our approach employs a collection of reusable ‘building‐block’ protocol mechanisms that may be composed together automatically based upon functional specifications. The resulting protocols execute in parallel on several target platforms including shared‐memory and message‐passing multiprocessors. ADAPTIVE provides a framework for (1) determining the functionality of customized lightweight protocol configurations that efficiently support multimedia applications and (2) mapping this functionality onto efficient parallel process architectures.

Transport system services that integrate operating system resources such as CPUs, virtual memory, and I/O devices with network protocols to support distributed multimedia applications running on local and wide area networks are described and classified. A taxonomy is presented, and four commercial and experimental transport systems are compared and evaluated in terms of their protocol processing support. The systems discussed are System V UNIX STREAMS, the BSD UNIX networking subsystem, the x-kernel, and the Choices Conduit system.>

This paper describes a high-performance transport system architecture called ADAPTIVE, 'A Dynamically Assembled Protocol Transformation, Integration, and Validation Environment'. The authors are developing ADAPTIVE to support multimedia applications running on high-speed networks. ADAPTIVE is a transformational system providing policies and mechanisms that automatically specify and configure a flexible adaptive transport system. In addition, it provides a controlled prototyping environment for monitoring, analyzing, and experimenting with the effects of different transport system designs and implementations on application performance.>

A description is given of a mathematical model of wire segment distribution on printed wiring boards. In this model segment, distributions are broken down into two components: net distributions and segment ratios. The net distribution is closely related to the CAD component placement process, whereas the segment ratio is closely related to the CAD net segmentation process. In most cases net distribution is by far the largest part of wiring. Peak segment congestion estimates and segment length estimates are obtained. Both of these estimates are expressed in terms of readily determined circuit properties. The model predicts segment congestion and length reliably.>

This paper applies an empirically determined relationship known as Rent's rule to the estimation of circuit pack parameters. In particular, equations are derived for 1) the number of leads passing through a region of a circuit pack based on the position of the region, and 2) the total lead length on a circuit pack. The estimation of these parameters is central to the modeling of circuit size and performance as well as many other important circuit parameters. A technique for determining the Rent parameters for a particular circuit pack is also derived. Finally, experimental validation of these models is described.

This paper discusses a new routing program. The program initially partitions a printed circuit board into regions called saturated zones. These saturated zones are subsequently merged by routing into larger and larger saturated zones until the final combination yields a routing for the entire board. The algorithm gains efficiency and effectiveness from the fact that restricted sets of wires are considered in parallel.

A backtracking algorithm for testing a pair of digraphs for isomorphism is presented. The information contained in the distance matrix representation of a graph is used to establish an initial partition of the graph's vertices. This distance matrix information is then applied in a backtracking procedure to reduce the search tree of possible mappings. While the algorithm is not guaranteed to run in polynomial time, it performs efficiently for a large class of graphs.

This paper discusses a technique whereby a logic design which is unconstrained may be replaced quasi-optimally with modules from a constrained library. Necessary and sufficient conditions for the replacement of modules within a network are developed and then reformulated as integer linear programs. These integer linear programs are solved during individual steps of a dynamic programming formulation of the network replacement problem. Execution time of the algorithm increases linearly with the network size and the algorithm produces optimal replacements of fan-out-free networks.

There are a number of methods which use a clause table to generate the prime implicants of a switching function. This paper describes a technique for extending the clause table approach to the minimization of multi-terminal networks. The specific extension described here extends the algorithm of Slagle et al. to generate the important implicants of a set of switching functions and to determine a minimum realization.