Forschung > Model-based Instrumentation of Distributed Applications

Model-based Instrumentation of Distributed Applications

Beteiligte an der Hochschule

  • Dipl.-Inform. (FH) Jan Schäfer
  • Prof. Dr. Reinhold Kröger


  • Cork Institute of Technology, Cork, Ireland


Beginn: Januar 2006
Ende: März 2008


  • J. Schäfer: "Lebenszyklusorientierte Performance-Instrumentierung verteilter Anwendungen", Gesellschaft für Informatik e.V. (GI), Köllen Druck+Verlag GmbH, Bonn, Informatiktage 2007. Fachwissenschaftlicher Informatik-Kongress, ISBN: 9783885794394, März 2007 (Link) (BibTeX)
  • Schäfer, Jan: "Model-based Instrumentation of Distributed Applications", M.Sc. Thesis, Cork Institute of Technology, Irland, März 2008 (BibTeX)
  • J. Schaefer; J. Stynes; R. Kroeger: "Model-Based Performance Instrumentation of Distributed Applications", IFIP, Springer Verlag, Distributed Applications and Interoperable Systems: 8th IFIP WG 6.1 International Conference, DAIS 2008, Oslo, Norway, June 4-6, 2008, Proceedings, Seite 210-223, Editors: R. Meier; S. Terzis, ISBN: 978-3540686392, Juni 2008 (BibTeX)


Dependable applications require quality assurance actions during their complete life-cycle. Delivering dependability for distributed applications is an even more complex task due to additional possible areas of failure (e. g. coordination or communication problems). Thus, controlling the behaviour of distributed applications is a challenging task. Software developers are often interested to know, how an application behaves in certain (critical) situations. This testing process starts in the development phase (e. g. for debugging purposes) and continues in the deployment phase (e. g. for debugging and monitoring purposes or performance measurements). With increasing complexity of applications, the need for methods and tools supporting these tasks is also increasing.
Instrumentation describes the process of inserting non-functional code segments into relevant sections of application source or binary code. Source code instrumentation standards include log4j/log4cxx (for logging and debugging) and Application Response Measurement (ARM, for timing and tracing of work units). An example for binary instrumentation on the other hand is the insertion of instrumentation code into Java byte code. Binary instrumentation does not require the source files of the instrumented application, but is not as flexible and customizable as source code instrumentation. At runtime, the inserted code generates information about the state of the application (or values of variables) that can be processed by additional (management) tools. However, instrumentation always adds overhead to applications and increases execution times. Thus, it often is mandatory to instrument sparsely, respectively, to remove or disable instrumentation code, when it is unneeded. Also, existing instrumentation standards and techniques have to be customized for each application, which means that changes in application-related source code often result in changes in instrumentation-related source code. This increases development and maintenance costs and is error-prone. The described problems suggest the development of methods and tools to help solve the described problems. The developed instrumentation system has to be generic and independent from programming languages and instrumentation standards as far as possible.
One way to accomplish this is to base the instrumentation process on abstract (generic) instrumentation patterns (e. g. the RPC-style request/response interaction pattern, synchronous and asynchronous messaging patterns), which are defined on higher abstraction levels. This corresponds to platform-independent models (PIM) as defined in OMG's Model Driven Architecture (MDA) for supporting platform-independent application development. This method of instrumentation is called model-based instrumentation. Ultimately, based on MDA and UML diagrams, the instrumentation process could already be started during the design phase ("instrumented design"). Step by step, the instrumented platform-independent application model could be transformed into a platformspecific model (PSM) using a selected programming language and instrumentation standard. In the end, platform-specific instrumentation code (PSC) could be injected into the application's source code automatically. This MDA-related approach to application instrumentation has not been researched yet and represents a new approach.
The instrumentation system should not only be usable with standalone but also with distributed applications that depend on middleware platforms. In addition to the Web service adaptation developed in this project, specific models for additional middleware platforms (e. g. CORBA, J2EE) could be developed for supporting specific instrumentation functionality and information.
To demonstrate the developed instrumentation approach, a basic collection of abstract interaction patterns has been defined, which can be used within arbitrary UML/XMI 2.0 compliant modeling tools.
The prototype allows the definition of instrumentation (measurement) points in an UML model by applying the UML profile for instrumentation (measurement and logging), which has been defined in this project. The exported model then has to be processed by an openArchitectureWare (oAW) cartridge (a plug-in), which has been developed specifically for the UML profile. oAW is a code generation framework allowing code generation from textual models that contains built-in support for XMI models. Thus, only a oAW cartridge had to be created to be able to generate instrumented source code from an instrumented UML model. The cartridge generates instrumentation code for two types of instrumentation: the Application Response Measurement (ARM) API is used for measurements, and the log4j API for logging.
The model-based instrumentation solution developed during this project has been integrated with the eMIVA project, which allows using UML-defined instrumentation points and the instrumentation information within the eMIVA tools.