RV’04 Preliminary Version jMonitor: Java Runtime Event Specification and Monitoring Library Abstract (original) (raw)
Related papers
An Aspect Oriented Programming Framework to Support Transparent Runtime Monitoring of Applications
International Journal of Advanced Computer Science and Applications
Monitoring the runtime state and behavior of applications is very important to evaluate the performance of these applications and to inspect their behavior. In case of legacy applications that have been developed without monitoring capabilities, there is a real challenge to accomplish runtime state monitoring. This research redefines runtime monitoring concept, and then presents an Aspect Oriented Programming (AOP) framework to equip applications with the capabilities to monitor their runtime state transparently. The framework, called RM Framework, supports three monitoring modes; Invasive-mode, Controlled-mode/(Functionality and Attribute), and Controlledmode/Selective. The framework is applied on a Java application as a case study. The results show smooth integration between application and runtime monitoring capabilities without affecting the target application consistency.
Providing Interoperability for Java-Oriented Monitoring Tools with JINEXT
Lecture Notes in Computer Science, 2005
While Java is getting an increasingly widely used programming language, Java Virtual Machine has become an important platform for networking and distributed computing. Due to the increasing complexity of programs, the demand for monitoring tool support (debuggers, performance analyzers etc.) for efficient computing is growing as well. A special, open interface J-OMIS, which provides an efficient support for monitoring distributed Java programs, is derived from the On-line Monitoring Interface Specification (OMIS) that enables to use multiple monitoring tools simultaneously. OMIS has been developed with interoperability in mind but not all structural and logical conflicts have been solved. Addressing the missing aspects of interoperability support within J-OMIS is intended to increase the simplicity of developing the monitoring tools which will synergetically support each other. In the paper we present the concept of JINEXT, an extension to OMIS, which is aimed to provide interoperability between monitoring tools.
Runtime data analysis for Java programs
… on Advancing the State-of-the- …, 2003
Program analysis plays a key role in many areas of software development, such as performance tuning, testing, debugging, and maintenance. Program analysis can be carried out statically or dynamically, and these two approaches are generally seen as being complementary to each other. In this paper, we will focus on runtime data analysis for object oriented systems in general and the Java 2 platform in particular. More specifically, we are investigating various runtime approaches to monitor the access and modification of variables in a Java program in order to keep track of the their usage history, being of particular interest for dynamic data flow analysis. Our results indicate that the Java 2 platform does not provide sufficient tools to enable comprehensive runtime data analysis in this context, especially when the complete source code of an application under investigation is unavailable.
JPMT: a Java performance monitoring tool
This paper describes our Java Performance Monitoring Toolkit (JPMT), which is developed for detailed analysis of the behavior and performance of Java applications. JPMT represents internal execution behavior of Java applications by event traces, where each event represents the occurrence of some activity, such as thread creation, method invocation, and locking contention. JPMT supports event filtering during and after application execution. Each event is annotated by high-resolution performance attributes, e.g., duration of locking contention and CPU time usage by method invocations. JPMT is an open toolkit, its event trace API can be used to develop custom performance analysis applications. JPMT comes with an event trace visualizer and a command-line event trace query tool for scripting purposes. The instrumentation required for monitoring the application is added transparently to the user during run-time. Overhead is minimized by only instrumenting for events the user is interested in and by careful implementation of the instrumentation itself.
A Monitoring platform for distributed Java applications
This paper presents a new Java oriented monitoring infrastructure that enables tools to observe, analyze and manipulate the execution of distributed Java applications independent of implementation details like instrumentation of monitored entities, hardware platform and application libraries. Tools can access the monitored application via a standardized interface defined by an On-Line Monitoring Interface Specification (OMIS) and extended by a set of new Java-specific services relating to garbage collection, class loading, remote method invocation, etc. The new monitoring functionality can be applied for building various kinds of tools and for adapting the already existing ones, such as performance analyzers, debuggers, etc., working in the on-line mode.
The application monitor aspect pattern
Modern applications are typically complex, multithreaded, distributed, and often should provide real-time responses and small-footprint. Due to such characteristics, most often, it is hard to understand the behavior of such systems and consequently detect the root causes of performance or reliability problems. In order to collect information about system's runtime behavioroperations' performance, internal threads status-the system developer is required to instrument the target application (and sometimes also its execution platform). Such monitoring code which allows the developer to reason about the code execution is not localized in a single application module; it must be included in many modules. As a consequence, the monitoring concern tends to be scattered across multiple application/platform modules and tangled with other application concerns. The Application Monitor pattern supports the separate definition of monitoringrelated functionalities concerns through the use of aspect-oriented programming. It decouples such concerns from the implementation of application-specific concerns, which in turn improves the system reusability and maintainability.
Proceedings of the first joint WOSP/SIPEW international conference on Performance engineering - WOSP/SIPEW '10, 2010
Many profilers for Java applications are implemented with low-level bytecode instrumentation techniques, which is tedious, error-prone, and complicates maintenance and extension of the tools. In order to reduce development time and cost, we promote building Java profilers using high-level aspect-oriented programming (AOP). We show that the use of aspects yields concise profilers that are easy to develop, extend, and maintain, because low-level instrumentation details are hidden from the tool developer. Our profiler relies on inter-advice communication, an extension to common AOP languages that enables efficient data passing between advice woven into the same method. We illustrate our approach with two case studies. First, we show that an existing, instrumentation-based tool for listener latency profiling can be easily recast as an aspect. Second, we present an aspect for comprehensive calling context profiling. In order to reduce profiling overhead, our aspect parallelizes application execution and profile creation.
Behavior investigation of concurrent Java programs: an approach based on source-code instrumentation
Future Generation Computer Systems, 2001
Java makes easier the coding phase of concurrent applications and provides friendly mechanisms for the information exchange among threads and different processes. The nature of communication and synchronization mechanisms and the actual parallelism of a distributed environment introduce potential sources of non-deterministic behavior in concurrent applications. In order to investigate on undesired effects related to non-deterministic behaviors, tracing and replay capabilities can be added to the programming environment. Such capabilities are useful for testing, debugging, monitoring, performance evaluation and program profiling purposes. This paper presents a solution for providing tracing and replay capabilities to a number of Java concurrent applications. Such a solution addresses portability and it is based on the automatic instrumentation of the original source code. Some transformation schemes have been applied to some classes in the standard Java packages in order to make easier and more efficient the automatic instrumentation task. It is shown how the object-oriented structure of Java can be exploited in a deep and efficient way both in the instrumentation and in the tracing and replay phases. (A. Bechini), prete@iet.unipi.it (C.A. Prete). 0167-739X/01/$ -see front matter © 2001 Elsevier Science B.V. All rights reserved. PII: S 0 1 6 7 -7 3 9 X ( 0 0 ) 0 0 0 9 5 -9