Monitoring of distributed Java applications

Abstract

The paper presents an approach to distributed Java monitoring based on an extension to the on-line monitoring interface specification that defines relationships between a monitoring system and on-line tools used to support the development of Java applications. The extension aims at defining a standard for an open interface that supports on-line software development tools. The paper also presents the implementation ideas on building a monitoring infrastructure based on the specification. This comprises the architecture of the infrastructure, the mechanism of interaction with the Java virtual machine, and sample scenarios of interactions between the tool and the monitoring system. The infrastructure provides a uniform monitoring support for different kinds of tools, like debuggers or performance analysers.

Introduction

Tools supporting parallel and distributed programming play an important role in the development of applications. Owing to its inherently distributed nature, the possibility of loading remote classes, and its platform independence, Java has become a widespread programming language for distributed applications in heterogeneous environments. Whereas Java applications are getting larger and more and more complex, the scarcity of powerful programming tools that allow to examine and eventually control the behaviour of these applications is becoming apparent. This is a concern especially when dealing with distributed programming. Although there are some tools for profiling distributed Java applications, like JProf [1], Jprobe [10] or JaViz [2], tools allowing to observe an application’s behaviour in more detail or even to control it, are rare. Java debuggers, for example, usually do not support applications distributed across multiple Java virtual machines (JVMs), a notable exception is JBuilder [3]. Furthermore, the incompatibility of tools does not allow to investigate different aspects of a program’s execution like, e.g. the high-level communication behaviour on the one hand and the detailed execution behaviour of single threads on the other.

Generally speaking, the term monitoring comprises techniques and mechanisms to observe and potentially manipulate applications. Tools used to monitor distributed applications have to consider all elements of the distributed system and must control the whole application distributed over different machines. Monitoring tools can be classified into two categories: on-line and off-line tools. The on-line tools run concurrently with the application, thus a user can interactively observe and influence the state of the application. In the case of off-line tools, information on the application’s execution is being stored on disk, usually as a trace file. After the application is finished, a tool uses the data gathered in the trace file for analysis activities.

To be able to observe and possibly manipulate a program’s execution, on-line tools need a specialized module which is called monitoring system. Usually this module is tightly integrated with the tool, but even in the case of Java, it must directly interface with the operating system and in addition depends on the specific implementation of the JVM. As a result, tools tend to be rather complex and cannot be easily ported to different target platforms. Due to this, the user would either need the monitoring module be adapted to the new platform, in order to be able to use the tool for performance analysis on other platform, or be forced to search for a new tool which if found most probably will not provide the same functionality as the previously used tool. This is one of the reasons why the users’ demands on tool capabilities are far from having been satisfied. In addition, tools come into conflict with each other when applied to the same application, e.g. debugger and performance analyser. A solution to these problems is to have a clearly separated monitoring system that provides a uniform interface for different kinds of on-line tools. The availability of such a system also greatly facilitates the development of new tools.

In practice, for distributed Java applications, there are no suitable monitoring systems at the moment. Although some approaches (e.g. [4], [8]) exist, they are usually targeted towards resource management or profiling only. Our approach to build a universal monitoring system is based on OMIS [15] and the OCM [16]. The OMIS project defines a standardized interface between the tools and the monitoring system. OMIS is not restricted to a single kind of tools, especially it supports tools oriented towards debugging as well as performance analysis and resource management. Originally, OMIS has been designed to support parallel systems, and its reference implementation, the monitoring system OCM has been targeted towards PVM and MPI applications.

The main goal of this paper is to present an approach to extend the OMIS specification for Java applications and the implementation concepts for building a monitoring infrastructure based on this specification. More specifically, at the beginning the paper discusses the deficiencies of existing tools’ functionality compared to the needs of Java monitoring, followed by an overview of the concepts of the extended version of the OMIS specification that supports Java applications. Next we present the architecture of the monitoring system compliant to this specification and the mechanism of interaction with the JVM. The last part of the paper focuses on sample scenarios of interactions between a tool and the monitoring system and their implications for implementation concepts.