Abstract: The Low Latency Fault Tolerance (LLFT) middleware provides fault tolerance for distributed applications deployed within a cloud computing or data center environment, using the leader/follower replication approach. The LLFT middleware consists of a Low Latency Messaging Protocol, a Leader-Determined Membership Protocol, and a Virtual Determinizer Framework. The Messaging Protocol provides are liable, totally ordered message delivery service by employing a direct group-to-group multicast where the ordering is determined by the primary replica in the group. The Membership Protocol provides a fast reconfiguration and recovery service when a replica becomes faulty and when a replica joins or leaves a group. The Virtual Determinizer Framework captures ordering information at the primary replica and enforces the same ordering at the backup replicas for major sources of non-determinism. The LLFT middleware maintains strong replica consistency, offers application transparency, and achieves low end-to-end latency.

Abstract: The LSST Data Management System is built on an open source software framework that has middleware and application layers. The middleware layer provides capabilities to construct, configure, and manage pipelines on clusters of processing nodes, and to manage the data the pipelines consume and produce. It is not in any way specific to astronomical applications. The complementary application layer provides the building blocks for constructing pipelines that process astronomical data, both in image and catalog forms. The application layer does not directly depend upon the LSST middleware, and can readily be used with other middleware implementations. Both layers have object oriented designs that make the creation of more specialized capabilities relatively easy through class inheritance. This paper outlines the structure of the LSST application framework and explores its usefulness for constructing pipelines outside of the LSST context, two examples of which are discussed. The classes that the framework provides are related within a domain model that is applicable to any astronomical pipeline that processes imaging data. Specifically modeled are mosaic imaging sensors; the images from these sensors and the transformations that result as they are processed from raw sensor readouts to final calibrated science products; and the wide variety of catalogs that are produced by detecting and measuring astronomical objects in a stream of such images. The classes are implemented in C++ with Python bindings provided so that pipelines can be constructed in any desired mixture of C++ and Python.

Abstract: A software update system automatically deploys software updates, approved by a provider of a process control system, to computer hosts that execute the process control system. The software update system includes a client application that generates a request for software updates applicable to the computer hosts and initiates automatic deployment of the software update to the host, and a server application that provides software update data to the client application in response to the request.

Abstract: Modern software systems are increasingly embedded in an open world that is constantly evolving, because of changes in the requirements, in the surrounding environment, and in the way people interact with them. The platform itself on which software runs may change over time, as we move towards cloud computing. These changes are difficult to predict and anticipate, and their occurrence is out of control of the application developers. Because of these changes, the applications themselves need to change. Often, changes in the applications cannot be handled off-line, but require the software to self-react by adapting its behavior dynamically, to continue to ensure the desired quality of service. The big challenge in front of us is how to achieve the necessary degrees of flexibility and dynamism required by software without compromising the necessary dependability.This paper advocates that future software engineering research should focus on providing intelligent support to software at run-time, breaking today's rigid boundary between development-time and run-time. Models need to continue to live at run-time and evolve as changes occur while the software is running. To ensure dependability, analysis that the updated system models continue to satisfy the goals must be performed by continuous verification. If verification fails, suitable adjustment policies, supported by model-driven re-derivation of parts of the system, must be activated to keep the system aligned with its expected requirements.The paper presents the background that motivates this research focus, the main existing research directions, and an agenda for future work.

Abstract: System and methodology automating delivery, licensing, and availability of software products are shown and described. In one embodiment, for example, a system of the present invention for delivering and licensing application software is described that comprises: a cloud server storing a plurality of software applications, including storing metadata indicating permitted licensing and operation of the software applications; a client computer for operating software applications, the client computer in communication with the cloud server; a client user interface at the client computer, which allows a user to request software applications from the cloud server; a communication module at the cloud server, for receiving requests from the user to operate particular software applications at the client computer; an authentication module at the cloud server, for authenticating the requests received from the user to operate certain software applications at the client computer; and a local library at the client computer for receiving from the cloud server the particular software applications requested by the user and making those applications available for operation at the client computer, pursuant to permitted licensing and operation specified by the metadata.

Abstract: The topic of reusable software in robotics is now largely addressed. Components based architectures, where components are independent units that can be reused accross applications, have become more popular. As a consequence, a long list of middlewares and integration tools is available in the community, often in the form of open-source projects. However, these projects are generally self contained with little reuse between them. This paper presents a software engineering approach that intends to grant middleware independance to robotic software components so that a clear separation of concerns is achieved between highly reusable algorithmic parts and integration frameworks. Such a decoupling let middle-wares be used interchangeably, while fully benefitting from their specific, individual features. This work has been integrated into a new version of the open-source GenоM component generator tool: GenоM3

Abstract: More and more, software systems involve autonomous and distributed software components that have to execute and interact in open and dynamic environments, such as in pervasive, autonomous, and mobile applications. The requirements with respect to dynamics, openness, scalability, and decentralization call for new approaches to software design and development, capable of supporting spontaneous configuration, tolerating partial failures, or arranging adaptive reorganization of the whole system. Inspired by the behaviour of complex natural systems, scientists and engineers have started to adjust their mechanisms and techniques for self-organization and adaption to changing environments. In line with these considerations, Mamei and Zambonelli propose an interaction model inspired by the way masses and particles in our universe move and self-organize according to contextual information represented by gravitational and electromagnetic fields. The key idea is to have the components actions driven by computational force fields, generated by the components themselves or by some infrastructures, and propagated across the environment. Together with its supporting middleware infrastructure available with additional information under http://www.agentgroup.unimore.it this model can serve as the basis for a general purpose and widely applicable approach for the design and development of adaptive distributed applications.

Abstract: Cloud computing represents a promising computing paradigm, where computational power is provided similar to utilities like water, electricity or gas. While most of the Cloud providers can guarantee some measurable non-functional performance metrics e.g., service availability or throughput, there is lack of adequate mechanisms for guaranteeing certifiable and auditable security, trust, and privacy of the applications and the data they process. This lack represents an obstacle for moving most business relevant applications into the Cloud. In this paper we devise a novel approach for compliance management in Clouds, which we termed Compliant Cloud Computing (C3). On one hand, we propose novel languages for specifying compliance requirements concerning security, privacy, and trust by leveraging domain specific languages and compliance level agreements. On the other hand, we propose the C3 middleware responsible for the deployment of certifiable and auditable applications, for provider selection in compliance with the user requirements, and for enactment and enforcement of compliance level agreements. We underpin our approach with a use case discussing various techniques necessary for achieving security, privacy, and trust in Clouds as for example data fragmentation among different protection domains or among different geographical regions.

Abstract: Event-driven automation of reactive functionalities for complex event processing is an urgent need in today's distributed service-oriented architectures and Web-based event-driven environments. An important problem to be addressed is how to correctly and efficiently capture and process the event-based behavioral, reactive logic embodied in reaction rules, and combining this with other conditional decision logic embodied, e.g., in derivation rules. This paper elaborates a homogeneous integration approach that combines derivation rules, reaction rules and other rule types such as integrity constraints into the general framework of logic programming, the industrial-strength version of declarative programming. We describe syntax and semantics of the language, implement a distributed web-based middleware using enterprise service technologies and illustrate its adequacy in terms of expressiveness, efficiency and scalability through examples extracted from industrial use cases. The developed reaction rule language provides expressive features such as modular ID-based updates with support for external imports and self-updates of the intensional and extensional knowledge bases, transactions including integrity testing and roll-backs of update transition paths. It also supports distributed complex event processing, event messaging and event querying via efficient and scalable enterprise middleware technologies and event/action reasoning based on an event/action algebra implemented by an interval-based event calculus variant as a logic inference formalism.

Abstract: This article presents the innovative features of Ginga-NCL, an open middleware specification for multimedia IPTV services. Ginga-NCL relies on the Nested Context Language, a domain-specific declarative language targeting multimedia application authoring. As a glue language, NCL relates media objects in time and space without restricting or imposing any media content type, including media objects with imperative and declarative code written using other languages. Other NCL features include support for multidevice presentations, content adaptations, presentation adaptations, and advanced code reuse. Ginga-NCL allows NCL applications to be modified on the fly by means of live editing commands. Initially defined as the standard middleware for the Brazilian terrestrial DTV system, Ginga-NCL has recently become part of ISDB standards and an ITU-T Recommendation for IPTV services.

Abstract: Medical devices historically have been monolithic units --- developed, validated, and approved by regulatory authorities as standalone entities. Despite the fact that modern medical devices increasingly incorporate connectivity mechanisms that enable device data to be streamed to electronic health records and displays that aggregate data from multiple devices, connectivity is not being leveraged to allow an integrated collection of devices to work together as a single system to automate clinical work flows. This is due, in part, to current regulatory policies which prohibit such interactions due to safety concerns.In previous work, we proposed an open source middleware framework and an accompanying model-based development environment that could be used to quickly implement medical device coordination applications --- enabling a "systems of systems" paradigm for medical devices. Such a paradigm shows great promise for supporting many applications that increase both the safety and effectiveness of medical care as well as the efficiency of clinical workflows. In this paper, we report on our experience using our Medical Device Coordination Framework (MDCF) to carry out a rapid prototyping of one such application --- a multi-device medical system that uses closed loop physiologic control to affect better patient outcomes for Patient Controlled Anelgesic (PCA) pumps.

Abstract: Real-time hybrid testing of civil structures, in which computational models and physical components must be integrated with high fidelity at run-time, represents a grand challenge in the emerging area of cyber-physical systems. Actuator dynamics, complex interactions among computers and physical components, and computation and communication delays all must be managed carefully to achieve accurate tests.In this paper we present a case study of several fundamental interlocking challenges in developing and evaluating cyber-physical systems for real-time hybrid structural testing: (1) how physical and simulated components can be integrated flexibly and efficiently within a common reusable middleware architecture; (2) how predictable timing can be achieved atop commonly available hardware and software platforms; and (3) how physical vs. simulated versions of different components within a system can be interchanged with high fidelity between comparable configurations. Experimental results obtained through this case study give evidence of the feasibility and efficacy of these steps towards our overall goal: to develop a Cyber-physical Instrument for Real-time hybrid Structural Testing (CIRST).

Abstract: This paper presents the design, implementation, and usage of a virtual laboratory for medical image analysis. It is fully based on the Dutch grid, which is part of the Enabling Grids for E-sciencE (EGEE) production infrastructure and driven by the gLite middleware. The adopted service-oriented architecture enables decoupling the user-friendly clients running on the user's workstation from the complexity of the grid applications and infrastructure. Data are stored on grid resources and can be browsed/viewed interactively by the user with the Virtual Resource Browser (VBrowser). Data analysis pipelines are described as Scufl workflows and enacted on the grid infrastructure transparently using the MOTEUR workflow management system. VBrowser plug-ins allow for easy experiment monitoring and error detection. Because of the strict compliance to the grid authentication model, all operations are performed on behalf of the user, ensuring basic security and facilitating collaboration across organizations. The system has been operational and in daily use for eight months (December 2008), with six users, leading to the submission of 9000 jobs/month in average and the production of several terabytes of data.

Abstract: A portable electronic device includes a memory and processor. The memory stores instructions, which are part of a retail mobile software purchase software application. The instructions, which when executed by the processor cause the portable electronic device to first transmit a search request for an item. The device receives item information including item description and item price and also receives a selection to purchase the item from a purchaser. The retail mobile software creates an order including the selected item and adds other selected items to the order. The retail mobile software application displays payment options for the order and receives a payment option selection for the order including the selected item. The retail mobile software application receives payment confirmation for the order including the selected item and displays receipt options for the order including the selected item. The retail mobile software application receives a selection of a receipt option and generates an electronic receipt for the order.

Abstract: The invention discloses a high-availability database cluster system based on message-oriented middleware, comprising a database service layer composed of a plurality of database servers and a middle layer arranged between an application layer and the database service layer; wherein, the middle layer comprises a plurality of application proxies, a plurality of database middleware and a message bus; the application proxy is used for connection redirection when fault occurs on service nodes so as to keep service uninterrupted and improve reliability; the database middleware is used for interception, analysis, processing and retransmission of the database request message; and the message bus runs through the database middleware and the database server, which is responsible for global sorting of reading and writing operation sent by the data middleware so as to ensure data consistency and sending of the sorting result to the database server. A feasible approach is provided for the invention in order to obtain a high-performance database with high availability. The invention has the advantages of high availability, good scalability and easy construction and management.

Abstract: Evaluating the performance (timing behavior, throughput, and resource utilization) of a software system becomes more and more challenging as today’s enterprise applications are built on a large basis of existing software (e.g. middleware, legacy applications, and third party services). As the performance of a system is affected by multiple factors on each layer of the system, performance analysts require detailed knowledge about the system under test and have to deal with a huge number of tools for benchmarking, monitoring, and analyzing. In practice, performance analysts try to handle the complexity by focusing on certain aspects, tools, or technologies. However, these isolated solutions are inefficient due to the small reuse and knowledge sharing. The Performance Cockpit presented in this paper is a framework that encapsulates knowledge about performance engineering, the system under test, and analyses in a single application by providing a flexible, plug-in based architecture. We demonstrate the value of the framework by means of two different case studies.

Abstract: A container service is capable of hosting large numbers of middleware components for multiple tenants A central container manager controls a plurality of compute nodes The central container manager receives middleware components from external devices or services and assigns the components to containers on one or more designated compute nodes Each compute node has a container management agent and one or more containers The container management agents activate and manage the appropriate number of containers to run the assigned middleware components The container management agent assigns each container on its compute node a limited set of privileges to control access to shared resources The central container manager and each node's container management agent monitor container load levels and dynamically adjust the placement of the middleware components to maintain balanced operation The compute nodes are grouped into clusters based upon the type of middleware components hosted on each compute node

Abstract: Many-task computing aims to bridge the gap between two computing paradigms, high throughput computing and high performance computing. Many-task computing denotes high-performance computations comprising multiple distinct activities, coupled via file system operations. The aggregate number of tasks, quantity of computing, and volumes of data may be extremely large. Traditional techniques found in production systems in the scientific community to support many-task computing do not scale to today's largest systems, due to issues in local resource manager scalability and granularity, efficient utilization of the raw hardware, long wait queue times, and shared/parallel file system contention and scalability. To address these limitations, we adopted a "top-down" approach to building a middleware called Falkon, to support the most demanding many-task computing applications at the largest scales. Falkon (Fast and Light-weight tasK executiON framework) integrates (1) multi-level scheduling to enable dynamic resource provisioning and minimize wait queue times, (2) a streamlined task dispatcher able to achieve orders-of-magnitude higher task dispatch rates than conventional schedulers, and (3) data diffusion which performs data caching and uses a data-aware scheduler to co-locate computational and storage resources. Micro-benchmarks have shown Falkon to achieve over 15K+ tasks/s throughputs, scale to hundreds of thousands of processors and to millions of queued tasks, and execute billions of tasks per day. Data diffusion has also shown to improve applications scalability and performance, with its ability to achieve hundreds of Gb/s I/O rates on modest sized clusters, with Tb/s I/O rates on the horizon. Falkon has shown orders of magnitude improvements in performance and scalability than traditional approaches to resource management across many diverse workloads and applications at scales of billions of tasks on hundreds of thousands of processors across clusters, specialized systems, Grids, and supercomputers. Falkon's performance and scalability have enabled a new class of applications called Many-Task Computing to operate at previously so-believed impossible scales with high efficiency.

Abstract: Ambient-intelligence (AmI) systems raise a series of new challenges in software and system development: Mobility, adaptability and heterogeneity are new concerns that have to be addressed Many of these concerns are common and therefore should be addressed by a common AmI infrastructure instead of each individual application This position paper proposes a bottom-up approach for the development of such a middleware infrastructure, which allows for easy customization to different hardware topologies

Abstract: Middleware for Web service compositions, such as BPEL engines, provides the execution environment for services as well as additional functionalities, such as monitoring and self-tuning. Given its role in service provisioning, it is very important to assess the performance of middleware in the context of a SOA. This paper presents SOABench, a framework for the automatic generation and execution of testbeds for benchmarking middleware for composite Web services and for assessing the performance of existing SOA infrastructures. SOABench defines a testbed model characterized by the composite services to execute, the workload to generate, the deployment configuration to use, the performance metrics to gather, the data analyses to perform on them, and the reports to produce. We have validated SOABench by benchmarking the performance of different BPEL engines.

Abstract: While a robot control framework generally focuses on real-time performance and efficient data exchange between cooperating tasks or processes, an application such as robot-assisted surgery often demands information from, and integration with, a number of other devices. Thus, the software framework for the integrated system may have different requirements and priorities than a framework for real-time robot control. This paper reports on a component-based architecture that seamlessly bridges the gap between real-time robot control and a distributed, integrated system. The starting point is the cisst library, which provides a component-based framework for lock-free and efficient data exchange between multiple threads within a single process, which is suitable for real-time robot control. This paper describes the extension of the cisst library to support distributed systems, while keeping the same programming model as the single-process, multi-threaded scenario. Thus, application software does not need to know whether the component providing services is within the same process, in a different process, or on a different computer. In comparison, most standard middleware packages support components that fall within the last two categories (different processes on the same computer or different computers). This does not allow them to take advantage of the higher performance that can be achieved using standard lock-free data structures that do not rely on the operating system or on middleware services. Thus, the novelty of this approach is that the same component-based architecture and associated programming model extends from a multi-threaded scenario (which provides the best real-time performance) to a standard multi-process distributed system.

Abstract: The increasing popularity of system virtualization in datacenters introduces the need for self-scaling of the management layer to cope with the increasing demands of the management workload. This paper studies the problem of self-scaling in datacenter management middleware, allowing the management capacity to scale with the management workload. We argue that self-scaling must be fast during workload bursts to avoid task completion delays, and self-scaling must minimize resource usage to avoid resource contention with applications. To address these two challenges, we propose the design of Tide, a self-scaling framework for virtualized datacenter management. A salient feature of Tide is its fast capacity-provisioning algorithm that supplies just-enough capacity for the management middleware. We evaluate the effectiveness of Tide with both synthetic and real world workloads. Our results show that the self-scaling capability in Tide can substantially improve the throughput of management tasks during management workload bursts while consuming a reasonable amount of resources.

Abstract: Recent advances in ubiquitous technologies facilitate location-aware and power-aware systems that can provide predefined services. Recent research efforts are based on control mechanisms for standby power reduction. Conventional systems are only designed for power reduction of the consumer electronics. However, due to their architectural limitations, the recent systems are not flexible with respect to LED light control for power reduction. We need to consider efficient autonomous power control based on intelligent devices and the power-aware service prediction in networked environments. In this paper, we propose a power-aware LED light enabler with light sensors, motion sensors and network interfaces. The LED light enabler also communicates with context-aware middleware using an intelligent power gateway that adaptively determines the optimal power control by analyzing user living patterns using sensing data obtained by devices. Our power-aware LED light enabler with adaptive middleware dynamically reconfigures the power-aware services. The proposed adaptive middleware facilitates the learning mechanism which analyzes the illumination and the user activity, and controls the LED lights only when users exist around the devices. Our enabler reduces power consumption up to 58% in comparison to a basic lighting system at the real office testbed.

Abstract: The ubiquitous computing scenario is characterized by heterogeneity of devices used to access services, and by frequent changes in the user's context. Hence, adaptation according to the user's context and the used devices is necessary to allow mobile users to efficiently exploit Internet-based services. In this paper, we present a distributed framework, named MIMOSA, that couples a middleware for context-awareness with an intermediary-based architecture for content adaptation. MIMOSA provides an effective and efficient solution for the adaptation of Internet services on the basis of a comprehensive notion of context, by means of techniques for aggregating context data from distributed sources, deriving complex contextual situations from raw sensor data, evaluating adaptation policies, and solving possible conflicts. The middleware allows programmers to modularly build complex adaptive services starting from simple ones, and includes tools for assisting the user in declaring her preferences, as well as mechanisms for detecting incorrect system behaviors due to a wrong choice of adaptation policies. The effectiveness and efficiency of MIMOSA are shown through the development of a prototype adaptive service, and by extensive experimental evaluations.

Abstract: Modern manufacturing systems are increasingly becoming highly dynamic due to the integration with advanced information technology in response to rapid changes in products and market conditions. A more flexible platform is critically needed for developing a new generation of manufacturing systems in order to address the challenges of uncertainty and flexibility requirements. This paper presents a mobile agent-based framework that supports dynamic deployment of control algorithms and tasks in automation systems. The framework is based on a mobile agent system called Mobile-C. It uses Ch, an embeddable interpretive C/C++ environment for mobile agent execution. Since Ch has been ported to most existing computing platforms, the framework can control automation systems that work in different operating systems. This mobile agent-based framework has been applied to the control of an automation work cell. Using an automaton package in Ch as a middleware, automation tasks can be described as high-level control programs and are portable to heterogeneous mechatronic devices that comprise the automation cell. The validation of the dynamic deployment of different tasks has been conducted in an experimental automation work cell that consists of a Puma 560, an IBM 7575, and a conveyor system. The results show that the mobile agent approach can effectively deploy and execute new control algorithms and tasks as mobile agents on any subsystem in a network.

Abstract: As mobile applications become more widespread, programming paradigms and middleware architectures designed to support their development are becoming increasingly important. The event-based programming paradigm is a strong candidate for the development of mobile applications due to its inherent support for the loose coupling between components required by mobile applications. However, existing middleware that supports the event-based programming paradigm is not well suited to supporting location-aware mobile applications in which highly mobile components come together dynamically to collaborate at some location. This paper presents a number of techniques including location-independent announcement and subscription coupled with location-dependent filtering and event delivery that can be used by event-based middleware to support such collaboration. We describe how these techniques have been implemented in STEAM, an event-based middleware with a fully decentralized architecture, which is particularly well suited to deployment in ad hoc network environments. The cost of such location-based event dissemination and the benefits of distributed event filtering are evaluated.