![[new]](gifs/misc/new_yellow.gif)
New and Revised
Books, Papers, and TutorialsNew and Revised
Books, Papers, and Tutorials
|
|
Books
|
|
This paper presents three contributions to the challenges of applying the OMG Model Driven Architecture (MDA) to develop and deploy distributed real-time and embedded (DRE) applications. First, we motivate our MDA tool called CoSMIC, which is based on the Model Integrated Computing (MIC) paradigm that provides the intellectual foundation for MDA. Second, we describe how CoSMIC's generative abilities can be used to configure and assemble DRE component middleware required to deploy DRE applications. Third, we delineate the challenges involved in developing CoSMIC. Based on our collective experience developing MIC tools and DRE middleware, we are confident that combining these two paradigms will yield significant advantages in developing model based DRE applications.
Distributed real-time and embedded (DRE) systems in which application requirements and environmental conditions may not be known a priori or may vary at run-time, mandate an adaptive approach to management of quality-of-service (QoS) to meet key constraints such as end-to-end timeliness. Furthermore, coordinated management of multiple QoS capabilities across layers of applications and their supporting middleware may be required to achieve necessary assurances of meeting these constraints. This paper offers two primary contributions to the state of the art in distributed computing systems: (1) a case study of our integration of multiple middleware QoS management technologies to manage quality and timeliness of imagery adaptively within a representative distributed avionics system and (2) empirical results and analysis of the impact of that integration on fundamental trade-offs between timeliness and image quality in that system.
Ensuring 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 implementations of Real-time CORBA are implemented in C++, which is widely considered to be more complicated and error-prone to program than Java and the Real-time Specification for Java (RTSJ). Although Real-time CORBA does not currently leverage key RTSJ features, such as scoped memory and real-time threads, integration of Real-Time CORBA and RTSJ is essential to ensure predictability required for Java-based DRE applications. This paper provides the following contributions to the study of middleware for DRE applications. First, we discuss the optimization strategies applied in the Real-time CORBA Portable Object Adapter (POA) layer. Second, we identify sources for applying RTSJ features within ZEN, which is our implementation of Real-time CORBA that runs atop multiple RTSJ implementations. Third, we qualitatively and quantitatively analyze predictability enhancements arising from applying RTSJ features to the Real-time CORBA POA layer. Our results show that combining optimizations with RTSJ features can considerably improve the performance and predictability of DRE applications written using Real-time CORBA and Java.
Distributed real-time and embedded (DRE) applications possess stringent quality of service (QoS) requirements, such as low latency, bounded jitter, and high throughput. An increasing number of DRE applications are developed using QoS-enabled middleware, such as Real-time CORBA and the Real-time Specification for Java (RTSJ), to ensure predictable end-to-end QoS. Real-time CORBA is an open middleware standard that allows DRE applications to allocate, schedule, and control the QoS of CPU, memory, and networking resources. The RTSJ provides extensions to Java that enable it to be used as the basis for Real-time CORBA middleware and applications.
This paper provides the following contributions to the study of QoS-enabled middleware for DRE applications. First, we outline key Real-time CORBA implementation challenges within the ORB Core, focusing on efficient buffer allocation and collocation strategies. Second, we describe how these challenges have been addressed in ZEN, which is an implementation of Real-time CORBA that runs atop RTSJ platforms. Third, we describe how RTSJ features, such as scoped memory and no-heap real-time threads, can be applied in a real-time ORB Core to enhance the predictability of DRE applications using Real-time CORBA and the RTSJ. Our results show that carefully applied optimization strategies can enable RTSJ-based Real-time CORBA ORBs to achieve effective QoS support for a range of DRE applications.
As middleware-based distributed applications become more pervasive, the need to improve scalability of those application becomes more important. Improving scalability can be achieved through the use of a load balancing service. Earlier generations of middleware-based load balancing services were simplistic, however, since they focused on specific use-cases and environments. These limitations made it hard to use the same load balancing service for anything other than a small class of distributed applications. Moreover, the lack of generality forced continuous redevelopment of application-specific load balancing services. Not only did this redevelopment increase distributed applications deployment costs, but it also increased the potential of producing non-optimal load balancing implementations since time-proven load balancing service optimizations could not be reused directly without undue effort. Recent advances in the design and implementation of middleware load balancing services overcome these limitations through several techniques, all of which are present in Cygnus, which is adaptive load balancing service based on the CORBA middleware standard.
This paper presents the following contributions to research on adaptive middleware-based load balancing techniques: (1) it presents the results of empirical benchmarks that systematically evaluate different load balancing strategies provided in Cygnus by measuring how they improve scalability, and (2) illustrates when adaptive load balancing, as opposed to non-adaptive, is suitable for use in a middleware based distributed application.
The proliferation of embedded systems and handheld devices with limited memory is forcing middleware and application developers to deal with memory consumption as a design constraint. This paper uses the POSA format to present the Virtual Component compound pattern that helps to reduce the memory footprint of middleware, particularly standards-based middleware such as CORBA or J2EE, by transparently migrating component functionality into an application on-demand. This compound pattern applies the Factory Method, the Proxy, and Component Configurator design patterns to achieve its goals. We describe the Virtual Component pattern as a separate named abstraction since each of these constituent pattern does not independently resolve the set of forces addressed by the Virtual Component pattern.
This paper provides two contributions to the study of high-performance object-oriented (OO) Web servers. First, it outlines the design principles and optimizations necessary to develop efficient and scalable Web servers and illustrates how we have applied these principles and optimizations to create JAWS. JAWS is a high-performance Web server that is designed to alleviate overheads incurred by existing Web servers on high-speed networks. In addition to its highly extensible OO design, it is also highly efficient, consistently outperforming existing Web servers, such as Apache, Java Server, PHTTPD, Zeus, and Netscape Enterprise, over 155 Mbps ATM networks on UNIX platforms.
Second, this paper describes how we have customized the JAWS OO design to leverage advanced features of Windows NT on multi-processor platforms linked by high-speed ATM networks. The Windows NT features used in JAWS include asynchronous mechanisms for connection establishment and data transfer. Our previous benchmarking studies demonstrate that once the overhead of disk I/O is reduced to a negligible constant factor (e.g., via memory caches), the primary determinants of Web server performance are its concurrency and event dispatching strategies.
Our performance results over a 155 Mbps ATM network indicate that
certain Windows NT asynchronous I/O mechanisms (i.e.,
TransmitFile) provide superior performance for large file
transfers compared with conventional synchronous multi-threaded
servers. Conversely, synchronous event dispatching performed better
for files less than 50 Kbytes. Thus, to provide optimal performance,
a Web server design should be adaptive, i.e., choosing to use
different mechanisms (such as TransmitFile) to handle
requests for large files, while using alternative I/O mechanisms (such
as synchronous event dispatching) on requests for small files.
Back to Douglas
C. Schmidt's home page.
Last modified 11:34:43 CDT 28 September 2006
C/C++ Users Journal Columns
Keynotes, Editorials, and Tutorials
