Evaluating the Performance Overhead of Object-Oriented Techniques in Embedded Software Design

This research involves experimental comparisons of the performance and memory overhead of an OO embedded real-time kernel with those of the non-OO version of the kernel. In this paper we present a discussion of the techniques used to produce an efficient OO design, the design and implementation of the OO kernel and the results of the experiments carried out to compare the performances of the OO and the non-OO kernels. I. INTRODUCTION Object-oriented programming offers code reusability, easy maintenance of software and the enforcement of data encapsulation and modularity. These benefits are congruent with the goals of PEBB (Power Electronics Building Block) systems, which are meant to introduce modularity, standardization and reusability in power electronics systems (2). However, the performance issues that OO programming introduces make it prohibitive especially in the context of real-time systems, where efficiency is a serious concern. DARK++ is an OO redesign of an embedded real-time kernel, DARK (Dataflow Architecture Real-time Kernel) written in C. The kernel and a representative set of power electronics control applications are being implemented in C++. Experimental evaluation of the performance of these applications is being performed in order to assess the efficiency of the OO kernel vis-à-vis that of the non-OO kernel. The reader is advised to refer to (1) for a discussion of the performance issues in OO systems and the design and functionality of some important classes in the system. DARK++ is designed based on Dataflow Architecture that supports asynchronous inter-component communication (2). Dataflow Architecture is characterized by a large number of components in order to facilitate modularization, high frequency of inter-component communication due to the large number of components, and special scheduling requirements due to the data-driven nature of dataflow applications. These characteristics necessitate special attention to the design of a dataflow system; in particular, the components in the system must be high-speed components, the inter-component communication must be efficient, and context switching must be efficient. Over and above the dataflow considerations, the OO performance issues also need to be considered in order to achieve a high-speed kernel. Our kernel, just like its non-OO counterpart, provides four versions - preemptive multithreaded, non-preemptive multithreaded, single-threaded dynamically scheduled, and single-threaded statically scheduled. The kernel is configurable so that one can choose to run an application with any of these versions of the kernel. Since a PEBB system could comprise multiple processors, we could have components controlled by different processors communicating with each other. This makes it necessary to handle intra-processor as well as inter-processor communications. For this purpose, we have two types of data channels; while Message Queues are used to connect components controlled by the same processor, Mailboxes are used for inter-processor communications. A mailbox may be viewed as a special case of a message queue. It is nothing but a message queue of unit size since inter-processor communications take place one unit of data at a time. This paper contains the results of the performance experiments carried out on DARK++ and DARK and presents a comparison of the two. We also present here, a description of the efficient OO design of the DARK++ system and some important high-speed kernel features (that are not necessarily specific to an OO kernel). The description of these design features will help understand the effect of each of them on the performance of the system, which is reported later in the paper. The following section discusses techniques that have been employed to overcome the OO performance issues. It describes in particular, how these have been employed in the DARK++ system. Section III presents a discussion of the most important kernel features like thread management, high- speed context switching, interrupt handling and mutual exclusion. These are implemented identical to the way they have been implemented in the DARK. In Section IV we provide a discussion of the four configurable versions of the kernel and their features and a few implementation details that would help us understand how the different options impact performance. Section V contains a comparison of DARK and DARK++ performance. We present the DFGs (Dataflow Graphs) of two control applications - the Open- loop three-phase Inverter, and the Closed-loop three-phase Inverter, and report the performance data for these two