Instrumenting annotated programs

Abstract

Instrumentation is commonly used to track application behavior: to collect program profiles; to monitor component health and performance; to aid in component testing; and more. Program annotation enables developers and tools to pass extra information to later stages of software development and execution. For example, the .NET runtime relies on annotations for a significant chunk of the services it provides. Both mechanisms are evolving into important parts of software development in the context of modern platforms such as Java and .NET.Instrumentation tools are generally not aware of the semantics of information passed via the annotation mechanism. This is especially true for post-compiler, e.g., runtime, instrumentation. The problem is that instrumentation may affect the correctness of annotations, rendering them invalid or misleading, and producing unforeseen side-effects during program execution. This problem has not been addressed so far.In this paper, we show the subtle interaction that takes place between annotations and instrumentation using several real-life examples. Many annotations are intended to provide information for the runtime; the virtual environment is a prominent annotation consumer, and must be aware of this conflict. It may also be required to provide runtime support to other annotation consumers. We propose an annotation taxonomy and show how instrumentation affects various annotations that were used in research and in industrial applications. We show how the annotations can expose enough information about themselves to prevent the instrumentation from accidentally corrupting the annotations. We demonstrate this approach on our annotations benchmark.

Sampling-based program execution monitoring

“…Though introducing minor side effects such as increase in execution time, instrumentation should maintain the program structure and functionality. To achieve this purpose, as pointed out by Marina Biberstein et al in [20], instrumentations should not remove program elements; variables defined by the original program might be read out but not written. According to them, instrumentation may add its own variables, and those variables may be read or written.…”

“…As summarized in [39], instrumentation is usually used to collect program profile and run-time information for various testing, debugging and analysis applications, such as detecting program deviation, dynamic slicing and alias analysis. It can also be used to monitor and track the program behavior [20]. However, software instrumentation is intrusive because it introduces considerable overhead to the execution that might perturb the behaviour of the original programs.…”

“…The reason for this difficulty is, as he points out, the complex and rich syntax of the source code along with the effect of compiler optimizations. In [20], as Marina Biberstein points out, another problem about instrumenting annotated program is that instrumentation might perturb the integrity of annotation, making them invalid, and generating unpredictable results during the execution of the programs, since the tools used for instrumentation are unaware of the semantics of information which is passed by the annotation mechanism. In this paper, Marina Biberstein presents a solution to address this interaction problem.…”

A Model of Message-Based Debugging Facilities for Web or Grid Services

“…One approach to manually instrumentation at source code is those inserted statements to dump logging information, e.g., logging services [23], and some programming languages support program annotation, e.g., Java and CLR. Code annotations constitute a powerful mechanism that enables passing information between programmers, tools, and the runtime, from the source code level up to the execution time [24]. Manual instrumentation and annotation to measure a program should be done when one gathers profiling information by inserting code to track various quantities.…”

Software maintainability benefits from annotation-driven code

“…These benefits also often result in better software maintenance and support. [1,4,5] In this paper we will concentrate on the benefits that annotations bring to generated code as well as benefits for tools that are used to develop such code.…”