Component frameworks simplify development of enterprise systems and enable code reuse, but most frameworks are unpredictable and hence unsuitable for embedded or real-time systems. Similarly, Java is increasingly being used to build embedded system software because of its portability and ease of use. The Real-Time Specification for Java (RTSJ) reduces the unpredictability in Java execution times by eliminating the need for a garbage collector. However, it introduces programming complexity that makes it difficult to build non-trivial applications. To bring the advantages of Java component development to DRE systems, while simultaneously simplifying the use of RTSJ, therefore, we have developed a new lightweight component model for RTSJ called Compadres. Compadres offers the following advantages: 1) Simple component definition in Java that abstracts away RTSJ memory management complexity; 2) System assembly from components by connecting ports that communicate through strongly-typed objects; 3) The Compadres compiler that automatically generates the scoped memory architecture for components, while the component framework handles communication between the components. To validate this work, we construct a nontrivial example application using the component framework, a simple real-time CORBA implementation. We then analyze the performance and efficiency of our component example versus a non-component example, RTZen. Our measurements show that our Compadres example built with components incurs only minor time overhead as compared to a comparable hand-coded example.

No abstract

Component technology can overcome many limitations of conventional Object Request Brokers (ORBs) in developing distributed, real-time, and embedded (DRE) applications. Component technology has particular advantages for building large-scale DRE systems. The CORBA Component Model (CCM) enables the composition and reuse of software components and the configuration of key non-functional aspects of DRE systems such as timing, fault-tolerance, and security. However, the CCM can introduce additional overhead to the runtime performance and code size of middleware. Hence, the overhead for using the CCM needs to be evaluated to determine if the CCM can be effectively employed in the design of high-reliability DRE applications. In this paper, we empirically evaluated the performance of OpenCCM, a Java-based implementation of the CCM standard, when configured with two Java ORBs: with ZEN, a real-time Java ORB, and with OpenORB, a desktop Java ORB. We measured throughput, latency, and jitter of method invocations for both ORBs configured with and without OpenCCM. We also measured the additional memory requirement introduced by the CCM implementation. We concluded that OpenCCM adds some overhead to both Java ORBs, affecting OpenORB's performance more than ZEN's. More development of the CCM may be necessary to bring its advantages to high-performance DRE systems.

Design patterns, components, and frameworks have been successfully used to build various distributed real-time, and embedded (DRE) systems such as high-performance servers, telecommunication systems, and control systems. An application developer may choose from several approaches to implement a distributed application and the choice of design patterns and their configuration can impact the overall performance of the system. Unlike components, design patterns are often descriptions of a programming approach and need to be reified for each application. However, some core pattern implementations can often be reused across applications, if they can be correctly configured to meet application requirements. Currently, there is no general way to quantify the performance of components and design pattern implementations across various dimensions such as throughput, response time, and scalability. The overall performance of applications that are composed from pre-coded components and patterns can be inferred using analytical techniques by modeling the behavior of the individual components. In particular, while we know from experience that patterns exhibit various tradeoffs in terms of performance and complexity; we would like to explore these tradeoffs in a formal way. Toward this goal, we make the following contributions in this thesis: 1) we develop analytical models for various design patterns using queuing models, 2) we present a technique to analyze the performance of combinations of design patterns as observed in real-world applications, and 3) we validate the models using empirical measurements.