Object Instance Profiling
|
|
- Maria Page
- 7 years ago
- Views:
Transcription
1 Object Instance Profiling Lubomír Bulej 1,2, Lukáš Marek 1, Petr Tůma 1 Technical report No. 2009/7, November 2009 Version 1.0, November Distributed Systems Research Group, Department of Software Engineering Faculty of Mathematics and Physics, Charles University Malostranské nám. 25, Prague, Czech Republic phone , fax Institute of Computer Science, Academy of Sciences of the Czech Republic Pod Vodárenskou věží 2, Prague, Czech Republic phone Abstract. Existing Java profilers mostly use one of two distinct profiling methods, sampling and instrumentation. Sampling is not as informative as instrumentation but the overall overhead can be small. Instrumentation is more informative than sampling, since it intercepts every entrance and exit in the measured code, but the overhead is large. In this paper, we propose a method that collects profiling information associated with a specific object instance, rather than with a specific code location. Our method, called object instance profiling, can collect contextual information similarly to other instrumentation methods, but can be used more selectively and therefore with lesser overhead. 1 Introduction Profiling is a general method for determining application performance characteristics, which is based on collecting various performance data during application execution. The results of profiling typically allow identifying performance critical parts of an application, which are then prime candidates for developer attention when improving performance or addressing a performance issue. Profiling techniques come in two basic flavors. One of them is sampling based profiling, which relies on periodic sampling 3 of various data during application execution. At the very least, the collected data includes the value of the processor instruction pointer register, but other data, such as values of processor and operating system performance counters, can be collected as well. The sampled values of the instruction pointer are then mapped to individual methods and modules of the profiled application to determine their contribution to the total execution time. Sampling based profiling is generally applicable to native code 3 The sampling is driven by interrupts from a timer or a processor performance counter.
2 applications, because the profiled application is executed without any modification in its code. For managed execution environments such as Java, or CLR, profiling must supported by the virtual machine to obtain performance data related to application code and not the virtual machine itself. Naturally, profiling incurs overhead in the application execution, which is largely dependent on the sampling period, and the amount and kind of collected performance data. The sampling period directly influences the precision of the results and can be configured to limit the profiling overhead. The other technique is instrumentation based profiling, which relies on instrumenting the original application with special code to collect performance data upon occurence of significant events in application execution. Depending on the placement of the instrumentation code in the application, the events can cover a wide range of situations, including method entry and exit, performing I/O operations, etc. Due to ability to relate performance data to particular application events, instrumentation based profiling can provide more accurate and more specific information on application performance, but requires specialized tools to perform application instrumentation for particular execution environment. Overhead of instrumentation based profiling depends on the number of instrumented places in the application as well as on the kind of performance data collected. To avoid excessive overhead, the instrumentation can be performed selectively or include support for activation and passivation of the instrumentation code at runtime. As for the kind of performance data collected during profiling, besides various performance counters, both profiling techniques often collect stack traces to provide more detailed information on the execution context. Using stack traces allows distinguishing among invocations of the same method by different callers, thus enabling, e.g., identification of code paths responsible for turning particular methods into hot spots. However, obtaining a stack trace is a time consuming operation, which significantly increases the profiling overhead. While the profiling overhead might be acceptable during development, it is undesirable to include support for instrumentation based profiling in production application to implement runtime monitoring. For this purpose, we need to limit the use of stack traces to minimum and employ different techniques for obtaining more information on execution context. To address the issue, we propose an instrumentation based profiling technique, referred to as object instance profiling, that uses object instances instead of stack traces to obtain information on the execution context. The technique is not a replacement for stack traces, because it can be only applied on instance methods and the provided context information is not equivalent to a call stack. But in many cases, the instance based context information is sufficient, and the technique can be also used to collect instance-specific performance data, which is difficult with stack traces. We describe the principles of object instance profiling in Section 2 and highlight the differences between stack trace and instance based context information. We provide overview of different implementation options in
3 Section 3 and discuss related work in Section 4. Finally, we discuss future work and conclude the paper in Section 5. 2 Instance based context information The results of commonly used profiling techniques, hereafter refered to as code profiling, are typically mapped back to application code with the granularity of methods, classess, and packages or name spaces. If stack traces are collected during profiling, the results are parametrized by the context (call stack) in which the code executed. Different performance exhibited on instances containing different data may be observed in the same code executed in different contexts, since different callers may use different instances. If a class only has a single instance, the performance will be the same in all contexts, but we may still be able to distill valuable information from the context-specific profiles. The proposed method, hereafter refered to as object instance profiling, does not provide explicit caller context, but allows to directly observe instance-specific code performance. The caller context provided by object instance profiling is indirect, tied to object instances. Naturally, if a class only has a single instance, the observed performance will not differ from that obtained through classic code profiling and we will be also unable to distinguish among different caller contexts, because callers sharing an object instance will appear to be in the same caller context. If a class has multiple instances, object instance profiling requires each instance to have a unique identity, which must be mapped back to code using the particular instance. The difficulty of this task varies with the kind of application and classes it is applied to. In case of component based applications, the difficulty may be lower, because such applications tend to have a static architectural backbone and typically require component instances to be named. On the other hand, the difficulty will be higher for general applications with less explicit architecture, or for library classess used only temporarily in method scope. Compared to classic code profiling with stack traces, the object instance profiling approach brings two potential advantages. The first is the reduced overhead of obtaining caller context. Even though the instance based context is not a direct substitute for call stack, it may be sufficient in many cases and, contrary to call stack, does not need to be constructed on every method invocation. The second advantage is the already mentioned ability to collect instance-specific performance data on class methods. To demonstrate the advantages of the approach, consider the following two scenarios. In one scenario, a method uses an abstract class or an interface to work with different types of instances. In case of classic instrumentation based code profiling, a method instrumentation code will associate performance data only with the class where the method was defined. If a method calls an overriden superclass method, also the performance data for the superclass method will be collected and associated with the superclass, increasing the profiling overhead and including it in the outer method performance data. Using the object instance
4 profiling, performance data will only be collected in the first outer method called on an instance, without duplicating the effort when calling overriden superclass methods. In another scenario, method code calls a particular method on multiple instances of the same class, each holding different data. If the called method execution path depends on the data, classic stack trace based code profiling will aggregate (different) performance data from all the instances, providing meaningless results. To obtain better results, such cases need to be identified and instrumented by hand [1], whereas the object instance based approach will provide instance-specific performance data that can be parametrized by instance content. 4 On the other hand, stack trace based context information is available for any method, not just an instance method. The stack trace provides information on linkage among classes, which is impossible to obtain when using instance based context information. Moreover, tracking context of an instance that is used throughout the whole application is very difficult, if not impossible. That, however, can be remedied by adding stack trace context information to the object instance profiling technique. If used selectively, it can mitigate the drawbacks of the technique in special cases while keeping the overhead low in the most common cases. 3 Implementation options Due to its nature, object instance profiling is best implemented as an instrumentation based profiling technique, which requires modifying the application code so that it collects performance data. There are many ways to instrument an application [2] and we do not intend to describe them here in detail. Even though the object instance profiling is a general technique, we are mostly interested in its implementation in a managed execution environment. Best suited for such environment are source code and byte code instrumentation techniques. There are several ways to implement the object instance profiling. Since the work on implementing object instance profiling is still in progress, we will shortly describe each of the implementation options and only explain the basic idea without going into much detail. The common goal in all cases is to wrap the original instance and provide it with a unique name that would be stable between multiple invocations and allow tracing the use of a particular instance back to code. 3.1 Proxy objects The most straightforward method to implement object instance profiling is to use proxy objects delegating method calls to the original instances. A proxy object will provide the same interface as the original object, but besides calling 4 Assuming the content does not change during the instance lifetime.
5 the original method on the target object to handle the call, the code of the proxy object will collect performance data (or trigger its collection). Depending on the link to the original method code, a proxy can be delegation based or inheritance based. In both cases, the implementation type of the proxy object differs from that of the original, even though it implements the same interface. Delegation based proxy object is typically a separate object instance that keeps explicit reference to the target object and uses it to invoke the original methods. Inheritance based proxy object extends the class of the original object and overrides all methods that have to be instrumented. Due to inheritance, the proxy and the original share the same object instance. The main advantage of using proxy objects is precise control over instrumented instances only the wrapped instances are instrumented and collect performance data. But there are several issues associated with proxy objects that need to be addressed in a particular context. The delegation based proxy objects can be applied basically to any object instance, including instances of final classes. However, the most burning issue is related to object identity. Since there are two objects, there are two object references and we must ensure that only the reference to the proxy object is used by other code. If the target object leaks reference to itself to other parties as a part of method argument, return value, or global data, or if it calls its own public methods, the proxy object will be bypassed. The proxy object can include special code to replace target object reference in return values, but little can be done for the other situations in which references are leaked. The inheritance based proxy objects elegantly sidestep the identity issue, because there is only a single object and therefore a single reference. However, the inheritance based approach cannot be easily applied to final classes. Additional issue plaguing the delegation based proxy objects is that the type of the proxy object is different from the target object. Therefore the types of all class members, method arguments and local variables intended to hold a reference to the target object must be changed to that of the proxy object, unless interfaces are used. This is not necessary for the inheritance based approach, because the proxy object class will be a subtype of the target object class. Another issue is that to use the proxy object approach, we need to control instance creation. Instances are usually created by using the new operator, which seems easy enough to intercept, but this is not necessarily true for larger projects. In projects using Spring or EJB, object instances are wired together using dependency injection and the instances are created using reflection, based on class names contained in external configuration files. Controlling instance creation in case of Spring or EJB therefore requires special support tailored to the particular framework. 3.2 Proxy methods An alternative method to implement object instance profiling is to wrap methods directly in the instrumented classes. The original methods will be renamed and called from the instrumentation code placed in methods using the original names.
6 This approach preserves object type and identity, and thus avoids most of the issues associated with using proxy objects. On the other hand, it does not provide precise control over instance instrumentation all instances are instrumented and the instrumentation code must determine at runtime whether to collect performance data for a particular instance. When instrumenting a selected class, we can either modify only the selected class, or the selected class and all the classes along the path to the root of the inheritance hierarchy. Single class modification. When instrumenting a single class only, all public or protected methods of the class have to be instrumented, i.e., including methods inherited from parent classes. If a class defines a method, it must be renamed and wrapped by the instrumentation code. If a class inherits a method from superclass, the instrumentation code has to explicitly call the superclass method. As a result, all public or protected method calls on the instrumented class instances go through the instrumentation stub and trigger collection of instance-specific performance data. Event though only a single class is modified, the instrumentation is not limited to that particular class. While parent classes are unaffected by the instrumentation, any classess derived from the instrumented class will be affected by the instrumentation sometimes only partially so, when the child class overrides a virtual method. This is an undesired side effect of inheritance and to suppress it, the instrumentation code has to check the instance type at runtime and collect performance data only for instances of the instrumented class. This can be done effectively by performing the check only once during instance creation and storing the result in a boolean variable that can be consulted by the instrumentation code on each method invocation. Instrumenting more classes in the inheritance hierarchy has one drawback, which is the accumulation of the instrumentation code from multiple classes. If an inherited method is defined in an ancestor class further in the class hierarchy, the invocation has to traverse a chain of proxy methods to reach the original code. 5 Even though only the first proxy method in the chain will collect the performance data, the traversal of the chain of proxy methods will add unnecessary overhead. Class hierarchy modification. To avoid long chains of proxy methods, we can spread the instrumentation along the class inheritance hierarchy. The idea is to create proxy methods only in classes which actually define the original methods, i.e., if a class inherits (but does not override) a method from an ancestor, the proxy method is created only in the ancestor. This helps to prune the chain of proxy methods, but we still need to check the instance type at runtime to determine whether to collect performance data. Moreover, while in the previous case the instrumentation code only needed to check the value of a boolean variable, in this case the value may need to be modified to disable performance data collection when calling an overriden method in the superclass. This is necessary to 5 Note that this is only true for some languages, e.g., Java. C++ makes it possible to call the original method directly from each proxy method.
7 avoid collecting performance data twice when a class overrides a virtual method and also calls the overriden method. 3.3 Instance identification In our instrumentation debate so far, we have assumed that performance data will be collected for all instances of the instrumented class. To allow collecting performance data from a specific instance, we need to be able to identify the instances at runtime. The most straightforward solution is to require the instances to provide a name, either in a field or as a result of method invocation. The value should be immutable even though the identification will be probably done only once when the instance is created. Another solution is to identify the instance by execution context in which the instance is created. The execution context can be obtained from a stack trace in our case, this does not incur a significant profiling overhead since it is only required once during object creation. However, this can lead to the same problems as with the proxy object interceptions. Multiple instances can be created at the same place in the code, especially when the instantiation can be driven from outside the application. 4 Related work In principle, our work could be related to many profiler projects, such as HProf [3], JFluid [4], JIP [5], JProfiler [6], JProbe [7], YourKit [8], and others. To the best of our knowledge, none of the profiler projects implements object instance profiling that, however, is probably not the most important observation to be made. A more interesting observation is that the overhead of the managed language profilers is not yet comparable with native profilers while OProfile [9] claims a typical overhead of 1-3%, JIP authors claim their profiler is extremely fast with 100% overhead, or HProf with overhead rising easily to the range of %. We believe this is one place where object instance profiling can bring an improvement. Although the profiling code is unlikely to have a significantly different overhead per observation, object instance profiling should incur this overhead less frequently than code profiling. Another topic our work has in common with many other profiler projects is the need for instrumentation. Although this need has been around for a long time, satisfactory instrumentation methods are still not available tools such as JVMTI [10] require bytecode manipulation, which is error prone and known to fail on some library classes, and frameworks such as AspectJ [11] exhibit similar problems on a higher level. Still, we believe we will be able to extend frameworks like AspectJ or InsECT [12] to intercept object instance invocations, to make them suitable for object instance profiling.
8 The analysis in Section 3 also points out that, without modifying the virtual machine internals, there might be no single way to intercept object instance invocations that would work in all situations. Unlike other profiling approaches, which (except for missing some library classes and sometimes interfering with reflection) appear to be reasonably complete, an object instance profiling tool would also have to identify situations in which the collected information is unreliable, e.g. because of reference leaking. By providing multiple interception methods, we believe we can make object instance profiling work in most practical situations. 5 Conclusion We have presented object instance profiling as a profiling method that can, compared with code profiling, achieve lower overhead and still present detailed performance information. The basic idea of the method is to intercept invocations of particular object instances, rather than particular code locations. The problem of object instance profiling is with implementation in current managed language environments, there seems to be no standard way to achieve object instance profiling. We work around the problem by designing three different interception methods with different combinations of advantages and drawbacks, aiming for a palette of methods of which some will likely be usable in any particular situation. Our work is currently in the prototyping stage the individual interception methods are being assessed in the context of a complex application case study in Java [13]. References 1. Whitehead, N.: Java run-time monitoring, Part 1: Run-time performance and availability monitoring for Java systems; page (2008) 2. Shende, S., Malony, A.D.: The TAU parallel performance system. Intl. Journal of High Performance Computing Applications 20(2) (2006) 3. Sun Microsystems, Inc.: Hprof: A heap/cpu profiling tool in J2SE (2004) 4. Sun Microsystems, Inc.: JFluid. (2003) 5. Public development: The Java interactive profiler. (2005) 6. ej-technologies GmbH: JProfiler. (2003) 7. Quest Software, Inc.: JProbe. (2003) 8. YourKit, LLC: YourKit. (2003) 9. John Levon, P.E.: OProfile. (2003) 10. Sun Microsystems, Inc.: JVM Tool Interface. (2004)
9 11. Eclipse Foundation: AspectJ. (1998) 12. Anil Chawla, A.O.: A generic instrumentation framework for collecting dynamic information. In: ACM SIGSOFT Software Engineering Notes. (2004) 13. itemis AG: Q-impress enterprise soa showcase. (2009)
Trace-Based and Sample-Based Profiling in Rational Application Developer
Trace-Based and Sample-Based Profiling in Rational Application Developer This document is aimed at highlighting the importance of profiling in software development and talks about the profiling tools offered
More informationThe Java Series. Java Essentials I What is Java? Basic Language Constructs. Java Essentials I. What is Java?. Basic Language Constructs Slide 1
The Java Series Java Essentials I What is Java? Basic Language Constructs Slide 1 What is Java? A general purpose Object Oriented programming language. Created by Sun Microsystems. It s a general purpose
More informationlanguage 1 (source) compiler language 2 (target) Figure 1: Compiling a program
CS 2112 Lecture 27 Interpreters, compilers, and the Java Virtual Machine 1 May 2012 Lecturer: Andrew Myers 1 Interpreters vs. compilers There are two strategies for obtaining runnable code from a program
More informationImplementing Java Distributed Objects with JDBC
Implementing Java Distributed Objects with JDBC Pritisha 1, Aashima Arya 2 1,2 Department of Computer Science Bhagwan Mahaveer institute of engineering & technology (BMIET), Deenbandhu Chhotu Ram University
More informationThe Evolution of Load Testing. Why Gomez 360 o Web Load Testing Is a
Technical White Paper: WEb Load Testing To perform as intended, today s mission-critical applications rely on highly available, stable and trusted software services. Load testing ensures that those criteria
More informationPART IV Performance oriented design, Performance testing, Performance tuning & Performance solutions. Outline. Performance oriented design
PART IV Performance oriented design, Performance testing, Performance tuning & Performance solutions Slide 1 Outline Principles for performance oriented design Performance testing Performance tuning General
More informationHabanero Extreme Scale Software Research Project
Habanero Extreme Scale Software Research Project Comp215: Java Method Dispatch Zoran Budimlić (Rice University) Always remember that you are absolutely unique. Just like everyone else. - Margaret Mead
More informationNetBeans Profiler is an
NetBeans Profiler Exploring the NetBeans Profiler From Installation to a Practical Profiling Example* Gregg Sporar* NetBeans Profiler is an optional feature of the NetBeans IDE. It is a powerful tool that
More informationPerformance Tools for Parallel Java Environments
Performance Tools for Parallel Java Environments Sameer Shende and Allen D. Malony Department of Computer and Information Science, University of Oregon {sameer,malony}@cs.uoregon.edu http://www.cs.uoregon.edu/research/paracomp/tau
More informationChapter 3: Operating-System Structures. System Components Operating System Services System Calls System Programs System Structure Virtual Machines
Chapter 3: Operating-System Structures System Components Operating System Services System Calls System Programs System Structure Virtual Machines Operating System Concepts 3.1 Common System Components
More informationMonitoring, Tracing, Debugging (Under Construction)
Monitoring, Tracing, Debugging (Under Construction) I was already tempted to drop this topic from my lecture on operating systems when I found Stephan Siemen's article "Top Speed" in Linux World 10/2003.
More informationIntegrating TAU With Eclipse: A Performance Analysis System in an Integrated Development Environment
Integrating TAU With Eclipse: A Performance Analysis System in an Integrated Development Environment Wyatt Spear, Allen Malony, Alan Morris, Sameer Shende {wspear, malony, amorris, sameer}@cs.uoregon.edu
More informationEclipse Visualization and Performance Monitoring
Eclipse Visualization and Performance Monitoring Chris Laffra IBM Ottawa Labs http://eclipsefaq.org/chris Chris Laffra Eclipse Visualization and Performance Monitoring Page 1 Roadmap Introduction Introspection
More informationObject Oriented Design
Object Oriented Design Kenneth M. Anderson Lecture 20 CSCI 5828: Foundations of Software Engineering OO Design 1 Object-Oriented Design Traditional procedural systems separate data and procedures, and
More informationCan You Trust Your JVM Diagnostic Tools?
Can You Trust Your JVM Diagnostic Tools? Isaac Sjoblom, Tim S. Snyder, and Elena Machkasova Computer Science Discipline University of Minnesota Morris Morris, MN 56267 sjobl014@umn.edu, snyde479@umn.edu,
More informationComp 411 Principles of Programming Languages Lecture 34 Semantics of OO Languages. Corky Cartwright Swarat Chaudhuri November 30, 20111
Comp 411 Principles of Programming Languages Lecture 34 Semantics of OO Languages Corky Cartwright Swarat Chaudhuri November 30, 20111 Overview I In OO languages, data values (except for designated non-oo
More informationSystem Virtual Machines
System Virtual Machines Introduction Key concepts Resource virtualization processors memory I/O devices Performance issues Applications 1 Introduction System virtual machine capable of supporting multiple
More informationInstrumentation Software Profiling
Instrumentation Software Profiling Software Profiling Instrumentation of a program so that data related to runtime performance (e.g execution time, memory usage) is gathered for one or more pieces of the
More informationOn Performance of Delegation in Java
On Performance of Delegation in Java Sebastian Götz Software Technology Group, Dresden University of Technology, Germany sebastian.goetz@mail.inf.tu-dresden.de Mario Pukall Database Research Group, Otto-von-Guericke-University
More informationUse of profilers for studying Java dynamic optimizations
Use of profilers for studying Java dynamic optimizations Kevin Arhelger, Fernando Trinciante, Elena Machkasova Computer Science Discipline University of Minnesota Morris Morris MN, 56267 arhel005@umn.edu,
More informationFaculty of Informatics and Information Technologies
Slovak University of Technology in Bratislava Faculty of Informatics and Information Technologies FIIT-5212-5770 Erik Šuta PERFORMANCE MONITORING OF JAVA APPLICATIONS Bachelor thesis Degree course: Informatics
More informationA MONITORING PLATFORM FOR DISTRIBUTED JAVA APPLICATIONS
TASKQUARTERLY8No4,525 536 A MONITORING PLATFORM FOR DISTRIBUTED JAVA APPLICATIONS WŁODZIMIERZFUNIKA 1,MARIANBUBAK 1,2, MARCINSMĘTEK 1 ANDROLANDWISMÜLLER3 1 InstituteofComputerScience,AGHUniversityofScienceandTechnology,
More informationChecking Access to Protected Members in the Java Virtual Machine
Checking Access to Protected Members in the Java Virtual Machine Alessandro Coglio Kestrel Institute 3260 Hillview Avenue, Palo Alto, CA 94304, USA Ph. +1-650-493-6871 Fax +1-650-424-1807 http://www.kestrel.edu/
More informationGary Frost AMD Java Labs gary.frost@amd.com
Analyzing Java Performance Using Hardware Performance Counters Gary Frost AMD Java Labs gary.frost@amd.com 2008 by AMD; made available under the EPL v1.0 2 Agenda AMD Java Labs Hardware Performance Counters
More informationQuestions? Assignment. Techniques for Gathering Requirements. Gathering and Analysing Requirements
Questions? Assignment Why is proper project management important? What is goal of domain analysis? What is the difference between functional and non- functional requirements? Why is it important for requirements
More informationInterpreters and virtual machines. Interpreters. Interpreters. Why interpreters? Tree-based interpreters. Text-based interpreters
Interpreters and virtual machines Michel Schinz 2007 03 23 Interpreters Interpreters Why interpreters? An interpreter is a program that executes another program, represented as some kind of data-structure.
More informationOptimising Cloud Computing with SBSE
Optimising Cloud Computing with SBSE David R. White & Jeremy Singer {david.r.white, jeremy.singer}@glasgow.ac.uk University of Glasgow Monday 25 July 2011 OUTLINE VIRTUAL MACHINES OPPORTUNITIES FOR SBSE
More informationZing Vision. Answering your toughest production Java performance questions
Zing Vision Answering your toughest production Java performance questions Outline What is Zing Vision? Where does Zing Vision fit in your Java environment? Key features How it works Using ZVRobot Q & A
More informationTECHNOLOGY WHITE PAPER. Application Performance Management. Introduction to Adaptive Instrumentation with VERITAS Indepth for J2EE
TECHNOLOGY WHITE PAPER Application Performance Management Introduction to Adaptive Instrumentation with VERITAS Indepth for J2EE TABLE OF CONTENTS ABOUT ADAPTIVE INSTRUMENTATION 3 WHY ADAPTIVE INSTRUMENTATION?
More informationExperimental Evaluation of Distributed Middleware with a Virtualized Java Environment
Experimental Evaluation of Distributed Middleware with a Virtualized Java Environment Nuno A. Carvalho, João Bordalo, Filipe Campos and José Pereira HASLab / INESC TEC Universidade do Minho MW4SOC 11 December
More informationManaging Variability in Software Architectures 1 Felix Bachmann*
Managing Variability in Software Architectures Felix Bachmann* Carnegie Bosch Institute Carnegie Mellon University Pittsburgh, Pa 523, USA fb@sei.cmu.edu Len Bass Software Engineering Institute Carnegie
More informationObjectives. Chapter 2: Operating-System Structures. Operating System Services (Cont.) Operating System Services. Operating System Services (Cont.
Objectives To describe the services an operating system provides to users, processes, and other systems To discuss the various ways of structuring an operating system Chapter 2: Operating-System Structures
More informationC Compiler Targeting the Java Virtual Machine
C Compiler Targeting the Java Virtual Machine Jack Pien Senior Honors Thesis (Advisor: Javed A. Aslam) Dartmouth College Computer Science Technical Report PCS-TR98-334 May 30, 1998 Abstract One of the
More informationWrite Barrier Removal by Static Analysis
Write Barrier Removal by Static Analysis Karen Zee and Martin Rinard Laboratory for Computer Science Massachusetts Institute of Technology Cambridge, MA 02139 {kkz, rinard@lcs.mit.edu ABSTRACT We present
More informationFachbereich Informatik und Elektrotechnik SunSPOT. Ubiquitous Computing. Ubiquitous Computing, Helmut Dispert
Ubiquitous Computing Ubiquitous Computing The Sensor Network System Sun SPOT: The Sun Small Programmable Object Technology Technology-Based Wireless Sensor Networks a Java Platform for Developing Applications
More informationCompiling Object Oriented Languages. What is an Object-Oriented Programming Language? Implementation: Dynamic Binding
Compiling Object Oriented Languages What is an Object-Oriented Programming Language? Last time Dynamic compilation Today Introduction to compiling object oriented languages What are the issues? Objects
More informationJava Interview Questions and Answers
1. What is the most important feature of Java? Java is a platform independent language. 2. What do you mean by platform independence? Platform independence means that we can write and compile the java
More informationARM-BASED PERFORMANCE MONITORING FOR THE ECLIPSE PLATFORM
ARM-BASED PERFORMANCE MONITORING FOR THE ECLIPSE PLATFORM Ashish Patel, Lead Eclipse Committer for ARM, IBM Corporation Oliver E. Cole, President, OC Systems, Inc. The Eclipse Test and Performance Tools
More informationJProfiler: Code Coverage Analysis Tool for OMP Project
CMU 17-654 & 17-754 Analysis of Software Artifacts Spring 2006 Individual Project: Tool Analysis May 18, 2006 Eun-young Cho echo1@andrew.cmu.edu JProfiler: Code Coverage Analysis Tool for OMP Project Table
More informationPerformance Improvement In Java Application
Performance Improvement In Java Application Megha Fulfagar Accenture Delivery Center for Technology in India Accenture, its logo, and High Performance Delivered are trademarks of Accenture. Agenda Performance
More informationReplication on Virtual Machines
Replication on Virtual Machines Siggi Cherem CS 717 November 23rd, 2004 Outline 1 Introduction The Java Virtual Machine 2 Napper, Alvisi, Vin - DSN 2003 Introduction JVM as state machine Addressing non-determinism
More informationEfficient database auditing
Topicus Fincare Efficient database auditing And entity reversion Dennis Windhouwer Supervised by: Pim van den Broek, Jasper Laagland and Johan te Winkel 9 April 2014 SUMMARY Topicus wants their current
More informationDeferred node-copying scheme for XQuery processors
Deferred node-copying scheme for XQuery processors Jan Kurš and Jan Vraný Software Engineering Group, FIT ČVUT, Kolejn 550/2, 160 00, Prague, Czech Republic kurs.jan@post.cz, jan.vrany@fit.cvut.cz Abstract.
More informationDescription of Class Mutation Mutation Operators for Java
Description of Class Mutation Mutation Operators for Java Yu-Seung Ma Electronics and Telecommunications Research Institute, Korea ysma@etri.re.kr Jeff Offutt Software Engineering George Mason University
More informationEmbedded Programming in C/C++: Lesson-1: Programming Elements and Programming in C
Embedded Programming in C/C++: Lesson-1: Programming Elements and Programming in C 1 An essential part of any embedded system design Programming 2 Programming in Assembly or HLL Processor and memory-sensitive
More informationSimple Solution for a Location Service. Naming vs. Locating Entities. Forwarding Pointers (2) Forwarding Pointers (1)
Naming vs. Locating Entities Till now: resources with fixed locations (hierarchical, caching,...) Problem: some entity may change its location frequently Simple solution: record aliases for the new address
More informationEffective Java Programming. efficient software development
Effective Java Programming efficient software development Structure efficient software development what is efficiency? development process profiling during development what determines the performance of
More informationA Practical Method to Diagnose Memory Leaks in Java Application Alan Yu
A Practical Method to Diagnose Memory Leaks in Java Application Alan Yu 1. Introduction The Java virtual machine s heap stores all objects created by a running Java application. Objects are created by
More informationGlassFish v3. Building an ex tensible modular Java EE application server. Jerome Dochez and Ludovic Champenois Sun Microsystems, Inc.
GlassFish v3 Building an ex tensible modular Java EE application server Jerome Dochez and Ludovic Champenois Sun Microsystems, Inc. Agenda Java EE 6 and GlassFish V3 Modularity, Runtime Service Based Architecture
More informationParallel Processing and Software Performance. Lukáš Marek
Parallel Processing and Software Performance Lukáš Marek DISTRIBUTED SYSTEMS RESEARCH GROUP http://dsrg.mff.cuni.cz CHARLES UNIVERSITY PRAGUE Faculty of Mathematics and Physics Benchmarking in parallel
More informationMonitoring Java enviroment / applications
Monitoring Java enviroment / applications Uroš Majcen uros@quest-slo.com Java is Everywhere You Can Expect More. Java in Mars Rover With the help of Java Technology, and the Jet Propulsion Laboratory (JPL),
More information2015 ej-technologies GmbH. All rights reserved. JProfiler Manual
2015 ej-technologies GmbH. All rights reserved. JProfiler Manual Index JProfiler help... 8 How to order... 9 A Help topics... 10 A.1 Profiling... 10 A.1.1 Profiling modes... 10 A.1.2 Remote profiling...
More informationUniversität Karlsruhe (TH) Forschungsuniversität gegründet 1825. Inheritance Depth as a Cost Factor in Maintenance
Universität Karlsruhe (TH) Forschungsuniversität gegründet 1825 Why is Inheritance Important? A Controlled Experiment on Inheritance Depth as a Cost Factor in Maintenance Walter F. Tichy University of
More informationA Flexible Security Architecture for the EJB Framework
A Flexible Security Architecture for the EJB Framework Frank Kohmann¹, Michael Weber², Achim Botz¹ ¹ TPS Labs AG, Balanstr 49, D-81541 München {frank.kohmann achim.botz}@tps-labs.com ² Abteilung Verteilte
More informationJVM Tool Interface. Michal Pokorný
JVM Tool Interface Michal Pokorný JVM TI Inspect & control execution on JVM (profiling, debugging, monitoring, thread analysis, coverage, ) Higher-level interface: Java Platform Debugger Architecture JVM
More informationA Framework for Automatic Performance Monitoring, Analysis and Optimisation of Component Based Software Systems
A Framework for Automatic Performance Monitoring, Analysis and Optimisation of Component Based Software Systems Ada Diaconescu *, John Murphy ** Performance Engineering Laboratory Dublin City University,
More informationGadget: A Tool for Extracting the Dynamic Structure of Java Programs
Gadget: A Tool for Extracting the Dynamic Structure of Java Programs Juan Gargiulo and Spiros Mancoridis Department of Mathematics & Computer Science Drexel University Philadelphia, PA, USA e-mail: gjgargiu,smancori
More informationHow accurately do Java profilers predict runtime performance bottlenecks?
How accurately do Java profilers predict runtime performance bottlenecks? Master Software Engineering How accurately do Java profilers predict runtime performance bottlenecks? Peter Klijn: Student number
More informationPerformance Measurement of Dynamically Compiled Java Executions
Performance Measurement of Dynamically Compiled Java Executions Tia Newhall and Barton P. Miller University of Wisconsin Madison Madison, WI 53706-1685 USA +1 (608) 262-1204 {newhall,bart}@cs.wisc.edu
More informationAn Easier Way for Cross-Platform Data Acquisition Application Development
An Easier Way for Cross-Platform Data Acquisition Application Development For industrial automation and measurement system developers, software technology continues making rapid progress. Software engineers
More informationJOURNAL OF OBJECT TECHNOLOGY
JOURNAL OF OBJECT TECHNOLOGY Online at www.jot.fm. Published by ETH Zurich, Chair of Software Engineering JOT, 2002 Vol. 1, No. 3 Special issue: TOOLS USA 2002 proceedings Evaluation of Assertion Support
More informationGETTING STARTED WITH ANDROID DEVELOPMENT FOR EMBEDDED SYSTEMS
Embedded Systems White Paper GETTING STARTED WITH ANDROID DEVELOPMENT FOR EMBEDDED SYSTEMS September 2009 ABSTRACT Android is an open source platform built by Google that includes an operating system,
More informationAutomated Validation & Verification of Software Paper Presentation
Regression Test Selection for Java Software Salvador Valencia Rodríguez Automated Validation & Verification of Software Paper Presentation Paper authors Mary Jean Harrold James A. Jones Tongyu Li Donglin
More informationPractical Performance Understanding the Performance of Your Application
Neil Masson IBM Java Service Technical Lead 25 th September 2012 Practical Performance Understanding the Performance of Your Application 1 WebSphere User Group: Practical Performance Understand the Performance
More informationEvaluation of Alternative Instrumentation Frameworks
Evaluation of Alternative Instrumentation Frameworks Dušan Okanović, Milan Vidaković Faculty of Technical Sciences University of Novi Sad Fruškogorska 11 Novi Sad, Serbia oki@uns.ac.rs minja@uns.ac.rs
More informationNew Methods for Performance Monitoring of J2EE Application Servers
New Methods for Performance Monitoring of J2EE Application Servers Adrian Mos (Researcher) & John Murphy (Lecturer) Performance Engineering Laboratory, School of Electronic Engineering, Dublin City University,
More informationNaming vs. Locating Entities
Naming vs. Locating Entities Till now: resources with fixed locations (hierarchical, caching,...) Problem: some entity may change its location frequently Simple solution: record aliases for the new address
More informationGrowing Agents - An Investigation of Architectural Mechanisms for the Specification of Developing Agent Architectures
Growing Agents - An Investigation of Architectural Mechanisms for the Specification of Developing Agent Architectures Virgil Andronache Matthias Scheutz University of Notre Dame Notre Dame, IN 46556 e-mail:
More informationBPM Scheduling with Job Scheduler
Document: BPM Scheduling with Job Scheduler Author: Neil Kolban Date: 2009-03-26 Version: 0.1 BPM Scheduling with Job Scheduler On occasion it may be desired to start BPM processes at configured times
More informationDesigning an Enterprise Application Framework for Service-Oriented Architecture 1
Designing an Enterprise Application Framework for Service-Oriented Architecture 1 Shyam Kumar Doddavula, Sandeep Karamongikar Abstract This article is an attempt to present an approach for transforming
More informationChapter 3: Operating-System Structures. Common System Components
Chapter 3: Operating-System Structures System Components Operating System Services System Calls System Programs System Structure Virtual Machines System Design and Implementation System Generation 3.1
More informationProfBuilder: A Package for Rapidly Building Java Execution Profilers Brian F. Cooper, Han B. Lee, and Benjamin G. Zorn
ProfBuilder: A Package for Rapidly Building Java Execution Profilers Brian F. Cooper, Han B. Lee, and Benjamin G. Zorn Department of Computer Science Campus Box 430 University of Colorado Boulder, CO 80309-0430
More informationAutomaton Programming and Inheritance of Automata
Declarative Approach to Implementing Automata Classes in Imperative Programming Languages Artyom Astafurov, Anatoly Shalyto (research supervisor), Fac. of Information Technologies and Programming St. Petersburg
More informationData Abstraction and Hierarchy
Data Abstraction and Hierarchy * This research was supported by the NEC Professorship of Software Science and Engineering. Barbara Liskov Affiliation: MIT Laboratory for Computer Science Cambridge, MA,
More informationFundamentals of Java Programming
Fundamentals of Java Programming This document is exclusive property of Cisco Systems, Inc. Permission is granted to print and copy this document for non-commercial distribution and exclusive use by instructors
More informationImplementation Aspects of OO-Languages
1 Implementation Aspects of OO-Languages Allocation of space for data members: The space for data members is laid out the same way it is done for structures in C or other languages. Specifically: The data
More informationProfiling and Testing with Test and Performance Tools Platform (TPTP)
Profiling and Testing with Test and Performance Tools Platform (TPTP) 2009 IBM Corporation and Intel Corporation; made available under the EPL v1.0 March, 2009 Speakers Eugene Chan IBM Canada ewchan@ca.ibm.com
More informationLast Class: OS and Computer Architecture. Last Class: OS and Computer Architecture
Last Class: OS and Computer Architecture System bus Network card CPU, memory, I/O devices, network card, system bus Lecture 3, page 1 Last Class: OS and Computer Architecture OS Service Protection Interrupts
More informationChapter 5 Names, Bindings, Type Checking, and Scopes
Chapter 5 Names, Bindings, Type Checking, and Scopes Chapter 5 Topics Introduction Names Variables The Concept of Binding Type Checking Strong Typing Scope Scope and Lifetime Referencing Environments Named
More informationThe Microsoft Way: COM, OLE/ActiveX, COM+ and.net CLR. Chapter 15
The Microsoft Way: COM, OLE/ActiveX, COM+ and.net CLR Chapter 15 Microsoft is continually reengineering its existing application and platform base. Started with VBX, continued with OLE, ODBC, ActiveX,
More informationOperating System Structures
COP 4610: Introduction to Operating Systems (Spring 2015) Operating System Structures Zhi Wang Florida State University Content Operating system services User interface System calls System programs Operating
More informationThe Design of the Inferno Virtual Machine. Introduction
The Design of the Inferno Virtual Machine Phil Winterbottom Rob Pike Bell Labs, Lucent Technologies {philw, rob}@plan9.bell-labs.com http://www.lucent.com/inferno Introduction Virtual Machine are topical
More informationTest Plan Evaluation Model
Satisfice, Inc. http://www.satisfice.com James Bach, Principal james@satisfice.com Version 1.12 9/25/99 Test Plan Evaluation Model The answer to the question How good is this test plan? can only be given
More informationWebSphere v5 Administration, Network Deployment Edition
WebSphere v5 Administration, Network Deployment Edition Loading Java Classes Web Age Solutions, Inc. 2003 6-32 Class Loader A class loader is a Java class that loads compiled Java byte code of other classes.
More informationRunning and Testing Java EE Applications in Embedded Mode with JupEEter Framework
JOURNAL OF APPLIED COMPUTER SCIENCE Vol. 21 No. 1 (2013), pp. 53-69 Running and Testing Java EE Applications in Embedded Mode with JupEEter Framework Marcin Kwapisz 1 1 Technical University of Lodz Faculty
More informationTerms and Definitions for CMS Administrators, Architects, and Developers
Sitecore CMS 6 Glossary Rev. 081028 Sitecore CMS 6 Glossary Terms and Definitions for CMS Administrators, Architects, and Developers Table of Contents Chapter 1 Introduction... 3 1.1 Glossary... 4 Page
More informationLoad balancing using Remote Method Invocation (JAVA RMI)
Load balancing using Remote Method Invocation (JAVA RMI) Ms. N. D. Rahatgaonkar 1, Prof. Mr. P. A. Tijare 2 1 Department of Computer Science & Engg and Information Technology Sipna s College of Engg &
More informationJonathan Worthington Scarborough Linux User Group
Jonathan Worthington Scarborough Linux User Group Introduction What does a Virtual Machine do? Hides away the details of the hardware platform and operating system. Defines a common set of instructions.
More informationUsing jvmstat and visualgc to Solve Memory Management Problems
Using jvmstat and visualgc to Solve Memory Management Problems java.sun.com/javaone/sf 1 Wally Wedel Sun Software Services Brian Doherty Sun Microsystems, Inc. Analyze JVM Machine Memory Management Problems
More informationPerformance Monitoring of Parallel Scientific Applications
Performance Monitoring of Parallel Scientific Applications Abstract. David Skinner National Energy Research Scientific Computing Center Lawrence Berkeley National Laboratory This paper introduces an infrastructure
More informationLogging in Java Applications
Logging in Java Applications Logging provides a way to capture information about the operation of an application. Once captured, the information can be used for many purposes, but it is particularly useful
More informationA Portable and Customizable Profiling Framework for Java Based on Bytecode Instruction Counting
A Portable and Customizable Profiling Framework for Java Based on Bytecode Instruction Counting Walter Binder Ecole Polytechnique Fédérale de Lausanne (EPFL), Artificial Intelligence Laboratory, CH-1015
More informationExample of Standard API
16 Example of Standard API System Call Implementation Typically, a number associated with each system call System call interface maintains a table indexed according to these numbers The system call interface
More informationChapter 1 Fundamentals of Java Programming
Chapter 1 Fundamentals of Java Programming Computers and Computer Programming Writing and Executing a Java Program Elements of a Java Program Features of Java Accessing the Classes and Class Members The
More informationCloud Computing. Up until now
Cloud Computing Lecture 11 Virtualization 2011-2012 Up until now Introduction. Definition of Cloud Computing Grid Computing Content Distribution Networks Map Reduce Cycle-Sharing 1 Process Virtual Machines
More informationParallel Processing over Mobile Ad Hoc Networks of Handheld Machines
Parallel Processing over Mobile Ad Hoc Networks of Handheld Machines Michael J Jipping Department of Computer Science Hope College Holland, MI 49423 jipping@cs.hope.edu Gary Lewandowski Department of Mathematics
More informationWhat s Cool in the SAP JVM (CON3243)
What s Cool in the SAP JVM (CON3243) Volker Simonis, SAP SE September, 2014 Public Agenda SAP JVM Supportability SAP JVM Profiler SAP JVM Debugger 2014 SAP SE. All rights reserved. Public 2 SAP JVM SAP
More informationPortable Profiling of Memory Allocation in Java
Portable Profiling of Memory Allocation in Java Walter Binder Ecole Polytechnique Fédérale de Lausanne (EPFL) Artificial Intelligence Laboratory CH-1015 Lausanne, Switzerland walter.binder@epfl.ch Abstract.
More information4. The accountant s product costing art
4. The accountant s product costing art How to move from cost pools to product costs Define an appropriate number of cost pools Each cost pool aggregates costs associated with some set of activities Estimate
More informationCOSA. COSA BPM Suite. Roadmap
COSA COSA BPM Suite Roadmap COSA Copyright Copyright 2009 BPS-Solutions GmbH, Pulheim, Germany. All rights reserved. The information in this document is subject to change without notice. No part of this
More information