Exact and Portable Profiling for the JVM Using Bytecode Instruction Counting

Binder, Walter; Hulaas, Jarle

doi:10.1016/j.entcs.2006.07.011

Cited by 13 publications

(20 citation statements)

References 26 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…It helps to detect hot spots and performance bottlenecks, guiding the developer to the parts of a program that should be improved. We have shown in [6] that this approach allows exact profiling with overheads that are about two orders of magnitude lower 15 than standard tools for Java. Thus, the developer no longer has to carefully select the sub-parts of his application that he wants to profile.…”

Section: Further Extensionsmentioning

confidence: 99%

“…A far more efficient approach taken here is to patch the real Thread class and add the needed reference directly to its set of instance fields. 6 The required functionality of getCurrentAccount() is unfortunately hard to implement during the bootstrapping of the JVM. During this short, but crucial period, there is an initial phase where Thread.currentThread() pretends that no thread is executing and returns the value null (this is in fact because the Thread class has not yet been asked by the JVM to create its first instance).…”

Section: Refining Getcurrentaccount()mentioning

confidence: 99%

See 1 more Smart Citation

Program transformations for light-weight CPU accounting and control in the Java virtual machine

Hulaas

Binder

2008

Higher-Order Symb Comput

Self Cite

View full text Add to dashboard Cite

Abstract.This article constitutes a thorough presentation of an original scheme for portable CPU accounting and control in Java, which is based on program transformation techniques at the bytecode level and can be used with every standard Java Virtual Machine. In our approach applications, middleware, and even the standard Java runtime libraries (i.e., the Java Development Kit) are modified in a fully portable way, in order to expose details regarding the execution of threads. These transformations however incur a certain overhead at runtime. Further contributions of this article are the systematic review of the origin of such overheads and the description of a new static path prediction scheme targeted at reducing them.

show abstract

Section: Further Extensionsmentioning

confidence: 99%

Section: Refining Getcurrentaccount()mentioning

confidence: 99%

Program transformations for light-weight CPU accounting and control in the Java virtual machine

Hulaas

Binder

2008

Higher-Order Symb Comput

Self Cite

View full text Add to dashboard Cite

show abstract

“…Our implementation, which is built using the ASM library 5 for bytecode manipulation and a Java agent to get access to and transform the classes, is based on previous approaches to deal with resource accounting and profiling in Java [10,38,39]. As in previous approaches, we compute the length of each basic block to count the number of executed instructions and we try to keep a cache of known methods with a single basic block.…”

Section: Implementation Strategymentioning

confidence: 99%

“…For example, for a simple Web server component we can define a contract on the number of instructions per second it may execute [10] and the maximum amount of memory it can consume. The number of messages can be specified per component or per component-port.…”

Section: Specifying Component Contractsmentioning

confidence: 99%

“…Current monitoring mechanisms [8][9][10] continuously interact with the monitored application to obtain precise data regarding the amount of memory and I/O used, the time spent executing a particular component or the number of call to a particular interface. Despite their precision, these monitoring mechanisms induce high overhead on the application; this prevents their use in production environments.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

ScapeGoat: Spotting abnormal resource usage in component-based reconfigurable software systems

Gonzalez-Herrera

Bourcier

Daubert

et al. 2016

Journal of Systems and Software

View full text Add to dashboard Cite

Modern component frameworks support continuous deployment and simultaneous execution of multiple software components on top of the same virtual machine. However, isolation between the various components is limited. A faulty version of any one of the software components can compromise the whole system by consuming all available resources. In this paper, we address the problem of efficiently identifying faulty software components running simultaneously in a single virtual machine. Current solutions that perform permanent and extensive monitoring to detect anomalies induce high overhead on the system, and can, by themselves, make the system unstable. In this paper we present an optimistic adaptive monitoring system to determine the faulty components of an application. Suspected components are finely analyzed by the monitoring system, but only when required. Unsuspected components are left untouched and execute normally. Thus, we perform localized just-in-time monitoring that decreases the accumulated overhead of the monitoring system. We evaluate our approach on two case studies against a state-of-the-art monitoring system and show that our technique correctly detects faulty components, while reducing overhead by an average of 93%.

show abstract