Challenges in generating qos-constrained software implementations

ABSTRACT

The limited processing power and memory capacities of early computing technologies often forced designers of real-time and embedded software to devise relatively sophisticated and complex architectural and programming patterns. The primary motivation, of course, was to eke out as much capability as the underlying implementation technologies could provide. Unfortunately, this tended to add complexity to the software, often making it very difficult to evolve, maintain, or port to different (e.g., more advanced) technologies. One of the primary sources of complexity in such systems is the intricate interleaving of application-specific concerns with implementation concerns that prevents easy distinction of one from the other.

As applications get more sophisticated, these technology sensitive development methods are proving to be increasingly greater barriers to the higher levels of productivity, functionality, and reliability required of modern systems. In many cases, these traditional methods are no longer deemed appropriate.

So-called model-driven development (MDD) methods address this issue by exploiting two fundamental techniques: First, they allow more direct specification of application solutions by providing language constructs that very closely reflect application concepts while abstracting out implementation- and technology-specific concerns. This not only simplifies design but also reduces the likelihood of design errors. Second, MDD calls for the use of computer-based automation in the process of implementation. This involves, notably, techniques of automatically generating code from the high-level application design. In many cases, this process can be fully automated, analogous to the way that third-generation programming language compilers produced machine-executable code.

However, when it comes to software systems with stringent quality of service (QoS) constraints, such as encountered in realtime and embedded software, the automation process becomes significantly more challenging. This is not only because such constraints are more stringent and, therefore, are more difficult to satisfy, but also because the auto-generation of implementations is heavily dependent on the underlying platform on which the implementation is to execute. In such cases, it may be necessary to utilize every opportunity offered by the underlying platform technology. Therefore, the ideal implementation generator would evaluate the platform technology and generate code that makes optimal use of its capabilities. Clearly, this requires an accurate and relatively detailed representation of the target platform. It also requires a detailed and precise specification of the QoS requirements of the application (deadlines, throughput, reliability, security, etc.).

In the first part of this presentation, we describe a promising model-based approach to specifying both platforms and the QoS requirements of applications. It takes advantage of two modeling language standards issued by the Object Management Group (OMG): the general-purpose modeling language UML 2 and the recently adopted UML profile for Modeling and Analysis of Real-Time and Embedded Systems (MARTE). This combination provides the necessary conditions for creating powerful automatic implementation generators that first determine the feasibility of a given application-platform combination and, if the combination appears feasible, generate an optimal implementation that fully utilizes the platform capabilities.

The realization of such generators is, at present, an unsolved problem that goes beyond just the basic code generation issue and involves research in a number of diverse areas. In the second part of the presentation, we analyze the key elements of this problem and explore some potential research directions.

INDEX TERMS

Primary Classification:
  D. Software
  D.3 PROGRAMMING LANGUAGES
      D.3.4 Processors
          Subjects: Code generation

General Terms:
Languages, Theory

Keywords:
model-driven development