Mark Panahi

RTZen: highly predictable, real-time java middleware for distributed and embedded systems

Distributed real-time and embedded (DRE) applications possess stringent quality of service (QoS) requirements, such as predictability, latency, and throughput constraints. Real-Time CORBA, an open middleware standard, allows DRE applications to allocate, schedule, and control resources to ensure predictable end-to-end QoS. The Real-Time Specification for Java (RTSJ) has been developed to provide extensions to Java so that it can be used for real-time systems, in order to bring Javas advantages, such as portability and ease of use, to real-time applications. In this paper, we describe RTZen, an implementation of a Real-Time CORBA Object Request Broker (ORB), designed to comply with the restrictions imposed by RTSJ. RTZen is designed to eliminate the unpredictability caused by garbage collection and improper support for thread scheduling through the use of appropriate data structures, threading models, and memory scopes. RTZens architecture is also designed to hide the complexities of RTSJ related to distributed programming from the application developer. Empirical results show that RTZen is highly predictable and has acceptable performance. RTZen therefore demonstrates that Real-Time CORBA middleware implemented in real-time Java can meet stringent QoS requirements of DRE applications, while supporting safer, easier, cheaper, and faster development in real-time Java.

A real-time service-oriented framework to support sustainable cyber-physical systems

Sustainability is an important issue with a growing interest. Two ICT technologies provide useful support for the sustainability of industrial systems: service-oriented architecture (SOA) and cyber-physical systems (CPS). SOA has been adopted in a variety of industrial systems due to its integration flexibility and process composability. CPS is a new technology to bring computational intelligence to physical devices and to make them mission- and situation-aware. We study a real-time SOA architecture to enhance sustainability and predictability in CPS. The proposed real-time SOA middleware builds the support for service accountability and global resource management for real-time service processes. Given a service plan and known resource constraints, the middleware monitors the performance and reserves resources in advance for each service in the process to ensure its real-time feasibility. A prototype of RT-SOA ESB has been implemented and evaluated.

A Framework for Real-Time Service-Oriented Architecture

Service-oriented architectures (SOA), thoughwidely accepted in a variety of industries, must be enhancedto support real-time activities in order to gain evengreater adoption.We present RT-Llama, a novel architecturefor real-time SOA to support predictability in businessprocesses. Based on a user-specified process and deadline,our architecture, containing global resource managementand business process composition components, can reserveresources in advance for each service in the process toensure it meets its end-to-end deadline. This is facilitatedby also creating a real-time enterprise middleware thatmanages utilization of local resources by using efficient datastructures and handles service requests via reserved CPUbandwidth. We demonstrate that RT-Llama’s reservationcomponents are both efficient and adaptable to dynamicreal-time environments.

Patterns and tools for achieving predictability and performance with real time Java

The real-time specification for Java (RTSJ) offers the predictable memory management needed for real-time applications, while maintaining Java s advantages of portability and ease of use. RTSJs scoped memory allows object lifetimes to be controlled in groups, rather than individually as in C++. While easier than individual object lifetime management, scoped memory adds programming complexity from strict rules governing memory access across scopes. Moreover, memory leaks can potentially create jitter and reduce performance. To manage the complexities of RTSJs scoped memory, we developed patterns and tools for RTZen, a real-time CORBA Object Request Broker (ORB). We describe four new patterns that enable communication and coordination across scope boundaries, an otherwise difficult task in RTSJ. We then present IsoLeak, a runtime debugging tool that visualizes the scoped hierarchies of complex applications and locates memory leaks. Our empirical results show that RTZen is highly predictable and has acceptable performance. RTZen therefore demonstrates that the use of patterns and tools like IsoLeak can help applications meet the stringent QoS requirements of DRE applications, while supporting safer, easier, cheaper and faster development in real-time Java.

The Design of Middleware Support for Real-Time SOA

Service-oriented architectures (SOA) provide application systems the flexibility and cost-savings of dynamically composing workflows from reusable services. However, current SOA frameworks do not provide support for real-time workflow planning and execution. The goal of the RT-Llama SOA middleware framework is to address these new requirements. It works both at the service-level, by enhancing existing SOA middleware with service execution reservation capabilities, and at the end-to-end workflow-level, by creating a distributed component infrastructure for deadline-based workflow composition. This paper focuses on the design and implementation of the Virtual CPU (VCPU) resource scheduling scheme in RT-Llama to achieve predictable process executions. We have created a prototype implementation of RT-Llama using Sun Real-time JVM running on Solaris OS. Experiments consisting of real world service applications show that requests with end-to-end deadlines can be admitted and completed before deadlines with the VCPU scheme. We also show that service class differentiation can be achieved.

Heuristic-based Service Composition for Business Processes with Branching and Merging

One of the challenges in SOA is to identify the services that can be used to build a service process. An SOA infrastructure must provide an efficient and effective way to select compatible web service(s) and compose them into a functional service process that satisfies a users needs. Moreover, the web services(s) selected may be integrated with structures such as branches and merges to fulfill a task. This paper describes our system architecture and strategies on web services composition based on semantic matching. Our strategies include backward service composition using a breadth-first search tree and heuristic prioritization.

A Flexible Schedule Reservation Scheme for Real-Time Service-Oriented Architecture

This paper studies a flexible scheduling data structure that is used to manage out-of-order service requests in real-time service-oriented architecture (RT-SOA) applications. We propose a hierarchical TBTree (hTBTree) to record server availability across a hierarchy of time intervals with different degrees of time granularity. Real-time services need to find enough time interval in hTBTree for their requested executions. The structure of hTBTree is designed to record only the availability of a resource during a time interval rather than the specific reserved time-slots for each request. It thus will automatically adjust existing reservations within their service intervals to make room for new reservation requests. Simulations have been conducted to study the acceptance ratio and performance of different tree-based data structures. Results show that by allowing flexibility in reservations, hTBTree can accept more real-time service requests compared with other fixed time-slot reservation scheme such as segment tree and the original TBTree. In this way, it also increases the overall system utilization.

Service Process Composition with QoS and Monitoring Agent Cost Parameters

Service-oriented architecture (SOA) provides a flexible paradigm to dynamically compose service processes from individual services. The flexibility, on the other hand, makes it necessary to monitor and manage service behaviors at runtime for performance assurance. One solution is to deploy software monitoring agents. In this paper, we present an approach to consider agent cost at process composition by selecting services with lower monitoring costs. We propose two algorithms to perform service selection with agent cost. IGA is able to achieve efficient service selection and bounded agent cost by modeling the problem as the weighted set covering (WSC) problem. We also study a heuristic algorithm to estimate the agent cost as part of the service utility function. The execution time of heuristic algorithm is shorter than IGA. On the other hand, the agent cost may not be consistently minimized using heuristic algorithms.

The Design of an Intelligent Accountability Architecture

As more enterprises turn to SOA for the flexible deployment of business processes, adaptable and highly configurable infrastructures can be used to ensure that end-to-end quality of service requirements are met via automatic and dynamic process monitoring, diagnosis, and routing. We present the intelligent accountability middleware architecture (LLAMA) to support extensible SOA-based service process composition, run-time management, and configuration. It includes the infrastructure to continuously monitor services within an active service workflow, and dynamically adapt by performing run-time process reconfigurations. An open source enterprise service bus (ESB) project, Mule, has been adopted to incorporate its routing and interception mechanisms to create the LLAMA ESB to achieve dynamic configurability and dynamic routing that can be controlled and adjusted at run-time through agents and other LLAMA components and brokers. We measure the performance of the LLAMA ESB, specifically, the overhead of interceptors, and the profiling and dynamic routing infrastructure. We find that there is no significant overhead imposed by the LLAMA ESB.

Adaptive techniques for minimizing middleware memory footprint for distributed, real-time, embedded systems

In order for middleware to be widely useful for distributed, real-time, and embedded systems, it should provide a full set of services and be easily customizable to meet the memory footprint limitations of embedded systems. We examine a variety of techniques used to reduce the memory footprint in middleware. We find that combining aspect-oriented programming with code shrinkers and obfuscators reduces the memory footprint of CORBA middleware to <5% of its original size, as customized for a small client application for a memory-constrained embedded device.