Jazz: A Tool for Demand-Driven Structural Testing
|
|
- Megan Bryant
- 5 years ago
- Views:
Transcription
1 Jazz: A Tool for Demand-Driven Structural Testing J. Misurda, J. A. Clause, J. L. Reed, P. Gandra, B. R. Childers, and M. L. Soffa Department of Computer Science University of Pittsburgh Pittsburgh, Pennsylvania USA {jmisurda,clausej,juliya,pgranda,childers}@cs.pitt.edu Department of Computer Science University of Virginia Charlottesville, Virginia USA soffa@cs.virginia.edu Abstract Software testing to produce reliable and robust software has become vitally important in recent years. Testing is a process by which software quality can be assured through the collection of information about software. While testing can improve software reliability, current tools typically are inflexible and have high overheads, making it a challenge to test large software projects. In this paper, we describe a new scalable and flexible tool, called Jazz, for testing Java programs. Jazz uses a novel demand-driven approach for node, branch, and def-use structural testing. It has a graphical user interface for specifying and running tests, a test planner to determine the most efficient way to test the program, and a dynamic instrumenter to carry out a test. Jazz has a low average overhead of 17.6% for branch testing, while in comparison, a traditional tool has an overhead of 89.9%. 1. Introduction In the last several years, the importance of producing high quality and robust software has become paramount [6]. Testing is an important process to support quality assurance by gathering information about the software being developed or modified. It is, in general, extremely labor and resource intensive, accounting for 50-60% of the total cost of software development [7]. The increased emphasis on software quality and robustness mandates improved testing methodologies. To test software, a number of techniques can be applied. One class of techniques that is widely used is structural testing, which checks that a given coverage criterion is satisfied. For example, branch testing checks that a certain percentage of branches are executed. Other structural tests include def-use testing in which pairs of variable definitions and uses are checked for coverage and node testing in which nodes in a program s control flow graph are checked. Unfortunately, structural testing approaches are often hindered by the lack of scalable and flexible tools. Current tools are not scalable in terms of both time and memory, limiting the number and scope of the tests that can be applied to large programs. These tools often modify the software binary to insert instrumentation for testing. In this case, the tested version of the application is not the same version that is shipped to customers and errors may remain. Testing tools are usually inflexible and only implement certain types of testing. For example, many tools implement branch testing, but do not implement node or def-use testing. In this paper, we describe a new tool for structural testing, called Jazz, that addresses these problems. This tool uses a novel demand-driven technique to apply different testing strategies in an efficient and automatic way. Our method relies on test plans that describe what test instrumentation should be inserted and removed ondemand in executing code to carry out testing strategies. A test plan is a recipe that describes how and where a test should be performed. The approach is path specific and uses the actual execution paths of an application to drive the instrumentation and testing. Once a test site is covered, the instrumentation is dynamically removed to avoid performance overhead, and the test plan continues. The granularity of the instrumentation is flexible and includes statement and structure level (e.g., loops, functions). Because this approach is dynamic and can insert and remove tests as a program executes, the same program that is tested can be shipped to a customer. Jazz uses a specification language to describe what to test. From the specification, a test plan can be automatically generated by a test planner. The test specification describes what tests to apply and under what conditions to apply them. The specification language has both a visual representation and textual form. The visual language is expressed through a graphical user interface (GUI). The GUI can be used to describe tests, automatically carry them out, and report results. Jazz is a complete and new implementation of our SoftTest framework [2] for structural testing. It implements a GUI, a test planner, and dynamic instrumenter for on-demand testing. Jazz is incorporated as a plug-in 1
2 Eclipse Plug-in Application Test Spec. JVM Test Planner Node Branch Def-Use Planner APIs Test Specification in the Eclipse integrated development environment (IDE) and the IBM Jikes Java Research Virtual Machine [1]. It supports branch, node and def-use testing over code regions in a program. Experiments show that Jazz s run-time overhead is very low in comparison to traditional testing tools that use static instrumentation. 2. Jazz: Testing Java Programs Figure 1 shows Jazz s components and how they interact. To carry out a test, a user constructs a test specification with the GUI. Next, the graphical representation of the test specification is converted into a textual form in a language called testspec. A testspec specification includes the relevant code segments to be tested and the actions needed in the testing process. If desired, testers can write specifications directly in testspec, rather than use the GUI. Once the user is ready to test the program, the specification is passed to a test planner. This step translates the specification into a test plan. In the next step, the test plan is used by the dynamic instrumenter to instrument the program and determine coverage. Finally, the test results are displayed by the GUI Test Specification Jikes RVM Test Plan Dynamic Instrumenter In testing a software application, a developer may wish to apply different tests to various code regions. The tests are also often applied with different coverage criteria. Jazz has a GUI for specifying the tests to apply, where to apply them, and under what conditions. A coverage criterion can also be specified for each region. As shown in Figure 2, the GUI lets an user visually create and apply a test specification. The GUI shows the complete Eclipse IDE and how Jazz is incorporated. The callouts in the figure show some of Jazz s GUI widgets for creating, running, and viewing test results. Test Results Figure 1: Jazz Tool Flow and Methodology To illustrate how the user interacts with the tool, the figure shows several steps. The figure shows that the user has selected several source lines in the Eclipse source editor (step 1). The selected lines are used to build a test specification. In this case, lines in the file Compress.java have been selected as a test region for branch testing. When a region is selected, a test specification is created and displayed by the GUI. Test specifications are shown in a specification viewer window (step 2). A specification may be changed or deleted from this window. To run the current tests, the user clicks a button on the Eclipse toolbar (step 3). Jazz automatically invokes the test planner, Jikes and the dynamic instrumenter. When the program completes, the test results are displayed as a bar graph in the specification viewer (step 4). The GUI also highlights covered and uncovered source lines in the Eclipse editor window Test Planner Using the test specification, the test planner decides how to test Java methods. The test planner is invoked every time a method is loaded by Jikes Just-in-Time compiler. The planner checks whether there is a test specification for any portion of the method. If a specification exists, then the planner generates a test plan for the relevant code in the method. Thus, only methods that are actually loaded and executed are tested. The main function of the test planner is to produce a test plan that determines where and how to instrument a method to do the test actions. The test plan describes how best to dynamically instrument a method to determine coverage. To generate a test plan, the planner identifies the locations where to instrument a test region, when to insert and remove instrumentation at each loca- 2
3 3: Create & Run Test 1: Select Code Region 2: Test Specification 4: Test Results Figure 2: Branch Coverage GUI for Jazz tion, and what to do at each location. Typically, instrumentation locations correspond to basic blocks (in the control flow graph of a test region) where coverage information is collected. For example, in def-use testing, there are instrumentation locations for each variable definition and all uses reachable from a definition. Instrumentation is inserted and removed on-demand as the program executes. For example, in node testing, when a particular basic block is executed, instrumentation is inserted in successor blocks. Once a block is hit, its instrumentation can be removed because the block is covered. In branch and def-use testing, the planner ensures that instrumentation remains until all edges out of a block or all uses of a definition are covered. Finally, the planner determines what actions to perform at each location. The actions are encoded in a payload that is executed at each location. In node testing, the payload updates coverage information, inserts instrumentation at successor blocks, and removes the instrumentation in the current block. The payloads for branch and def-use testing are similar, except they check whether all edges or def-use pairs are covered. When multiple tests are applicable at a location, the test planner generates a customized payload for that location. For example, in def-use testing, there may be several definitions and uses within a single basic block. The custom payload for such a block inserts instrumentation at uses reachable from the definitions. It also updates the coverage for the uses in the current block Dynamic Instrumenter With the test plan from the planner, the dynamic instrumenter provides the functionality to insert and remove instrumentation at run-time. This interface is targeted by the test planner. The dynamic instrumenter operates on target machine code generated by Jikes. Dynamic instrumentation (that can be removed/inserted at runtime) is implemented with fast breakpoints [5]. A fast breakpoint replaces an instruction in the target machine code with a jump to a breakpoint handler that invokes the test instrumentation payload from the test planner. The dynamic instrumenter s API provides primitives, such as the placement of successor breakpoints, storing test-specific data, and removal of breakpoints, for con- 3
4 structing fast breakpoints with varying payloads. The instrumentation constructed with the API is highly scalable since only relevant portions of the program are instrumented for only as long as needed. 3. Experimental Results We used Jazz to measure the node, branch, and def-use coverage of the SPECjvm98 benchmarks. In this experiment, the test specification covers all loaded methods and the test inputs are the data sets from SPECjvm98. The benchmarks were run on a 2.4 GHz Pentium IV machine with 1 GB of RAM and RedHat Linux. Benchmark Branch Node Def-Use compress 58% 90.6% 89.8% jess 46.8% 80.3% 71.8% db 44.4% 76.9% 75% javac 38.9% 75% 66.9% mpegaudio 60.9% 88.7% 90.5% mtrt 50.6% 90.3% 87.3% jack 55.6% 82.2% 73.4% Table 1: Percentage coverage Table 1 shows the coverages for the three tests supported by Jazz. The coverages for branch testing are % and for node testing, %. The tool reported coverage of % for def-use testing. We also investigated Jazz s performance and compared it to a traditional approach based on static instrumentation. To ensure a fair comparison, we implemented a separate tool that uses static instrumentation in our framework. This tool instruments a method s binary code before run time and does not remove instrumentation. It is similar to Rational PurifyPlus [3] and JCover [4]. Jazz and the static tool differ only in ondemand versus static instrumentation. We measured run-time when the benchmarks were run directly in Jikes without testing, with Jazz and with the static tool. For brevity, we summarize the run-times only for branch testing. When run without testing, the benchmarks take seconds. With the static branch testing tool, run-time is increased dramatically. It varies from seconds and incurs an overhead of % (average 89.9%) over native execution. Jazz has much lower run-times than the static tool. Its run-time is seconds and the performance overhead is only 0.3% to 7.8% (average 17.6%). Jazz has less overhead than the static tool because instrumentation is inserted and removed on-demand. Indeed, in tight loops, instrumentation is typically removed within the first few loop iterations, which keeps overhead low (e.g., compress has a tight loop). As these results show, Jazz is an effective tool, with minimal performance overhead. 4. Related Work There are a number of commercial tools that perform coverage testing on Java programs, including JCover and IBM s Rational PurifyPlus. These tools statically instrument the program to perform coverage testing. The work that is most closely related to ours is a tool developed with the ParaDyn parallel instrumentation framework [8]. This tool dynamically inserts and removes instrumentation on method invocations to do node coverage, where we take a similar approach for branch coverage. Unlike our approach, instrumentation is inserted in the whole method when it is invoked and a separate garbage collection pass removes the instrumentation. Our technique instruments only executed paths and removes instrumentation as soon as possible. 5. Summary This paper described a new tool, called Jazz, for software testing of Java programs that relies on a novel scheme for dynamically inserting and removing instrumentation on-demand. The performance results with Jazz are very encouraging: The average overhead for branch testing with Jazz was 17.6%, while a tool that used static instrumentation had an overhead of 89.9%. Jazz supports branch, node, and def-use testing. It is available for Eclipse 3.0 and the IBM Jikes Java RVM. References [1] IBM, Jikes RVM, oss/jikesrvm [2] B. Childers, M. L. Soffa, J. Beaver, et al. SoftTest: A framework for software testing of Java programs, Eclipse Technology Exchange, [3] IBM, Rational PurifyPlus, [4] JCover, [5] P. Kessler, Fast breakpoints: Design and implementation, ACM SIGPLAN Conf. on Programming Languages, Design and Implementation, [6] L. Osterweil et al., Strategic directions in software quality, ACM Computing Surveys, Vol. 4, [7] W. Perry, Effective Methods for Software Testing, John Wiley & Sons, Inc., New York, [8] M. Tikir and J. Hollingsworth, Efficient instrumentation for code coverage testing, Int l. Symp. on Software Testing and Analysis,
5 Appendix: Presentation Overview Depending on the amount of time allocated for demos and the venue (e.g., during a separate poster session or conference presentation), we will demonstrate the Jazz structural testing tool with a combination of a presentation and a tool walk-through. The presentation will describe the challenges to flexible and scalable testing and how demand-driven structural testing addresses these challenges. We will also present our framework for demand-driven structural testing and the techniques that are used in Jazz. After presenting the approach and basic techniques, we will demonstrate demand-driven branch testing with Jazz on a complete application, as described below. Finally, after the demonstration, we will present the performance of Jazz in comparison to traditional structural testing approaches. 1. Introduction This part of the presentation will motivate and introduce the need for structural software testing. We will discuss the challenges, as described in the paper, faced when testing large, complex software systems. Next, we will explain our approach: demand-driven structural testing and how this approach addresses the problems with faced when testing large software projects. Finally, we will describe Jazz and explain the various capabilities and components of the tool. 1.1 Challenges to Structural Testing Structural testing is the process of discovering run-time properties of a program specifically those pertaining to control flow. It uses control flow coverage information to help ensure software quality. Coverage information is collected by instrumenting a program. Traditionally, instrumentation is inserted statically prior to program execution. However, this approach is not scalable. Instrumentation code is left in place and continues to be executed even after coverage information is collected. 1.2 Goals and Approach Our research is developing new approaches to structural testing, and we have built a practical and useful tool that incorporates many of our approaches for structural testing of Java programs. Jazz has a number of goals: 1. The tool must be scalable and flexible. a. Scalable: Large programs can be tested as easily as small ones. b. Flexible: Easy to add new tests and modify existing tests. 2. It should be possible to apply multiple testing strategies to a program.
6 3. The tool should have a low overhead, which allows more tests to be run in a smaller amount of time. Importantly, with scalable and flexible testing approaches and tool, it becomes feasible to test large software projects. To achieve these goals, we use an approach that is specification-driven, path specific, and dynamic. 1.3 Tool Overview Our tool is composed of four main components which can be seen in the figure above. The first component is the test specification. The specification is generated using an Eclipse GUI. Using this GUI the tester is able to choose which regions to instrument and which tests to perform on those regions. The second component is the test planner. The planner uses the test specification to generate a test plan which specifies where, when, and how to instrument the program. The planner also creates a test table and test payloads. The test table encodes where and when to instrument and records the results of instrumentation. The test payload specifies what actions to perform at each instrumentation point. The third component is the dynamic instrumenter. It provides an API to manipulate the target machine code. The fourth component is the results viewer. The viewer presents the results of the each test to the use.
7 2. Demand Driven Structural Testing This section will explain how demand driven testing can reduce the amount and cost of instrumentation needed to collect coverage information. For the remainder of the presentation, we will focus our examples and analysis on Branch Coverage testing. Branch coverage provides a balance between the simplicity of Node coverage and the complexity of Def-Use coverage and allows the audience to appreciate the benefit of our tool with out becoming lost in implementation details. We will step through a branch testing example using our demand driven technique on a control flow graph, such as that shown above. We will show how demand-driven testing inserts and removes instrumentation dynamically along a path of execution and how coverage information is recorded. After demonstrating the demand driven technique for branch coverage, we will discuss how the technique is used for node and def use coverage. For node coverage a single instrumentation probe is placed at the first block in the control flow graph. As execution proceeds instrumentation is placed in successors of the current block unless a block has been covered. We don t need to worry about replacing instrumentation since we are only recording the coverage of individual basic blocks--not paths between them. For def-use testing, we need two types of instrumentation probes, definition probes and use probes. Definition probes record the start of a def-use pair and need to remain until all uses that
8 can be reached from the definition are also covered. Use probes record that a chain between a definition and a use has been covered. The use probes do not need to remain and can be removed as soon as they have been covered. 3. Demo Our tool demonstration will have two primary parts: an end-to-end walkthrough of the tool s operation, and an example of testing an application with static instrumentation (as used by traditional testing tools, such as IBM s Rational PurifyPlus) and dynamic instrumentation (as used by Jazz). 3.1 Walkthrough We will demonstrate the Eclipse GUI for branch coverage pictured below. Several tests will be constructed using different features of the interface to select and build code regions. The tree view on the right hand side of the interface can be used to select entire methods for testing. It is also possible to select specific line ranges by highlighting them in the central editing view. After specifying ranges to test the interface will generate a specification that is passed to the test planner. The dynamic instrumenter will then execute the plan created by the test planner and return the results to the GUI. Results for each test are displayed in the table at the bottom of the interface. 2. Click the add test button to add the selection to the test specification 3. Tests show up here 1. Select a method or a region of code
9 4. Click the run tests button to execute the program with the current test plan 5. Results show up here after the program runs 3.2 Application Demonstration To show the benefit of using our demand-driven testing with dynamic instrumentation over a traditional approach with static instrumentation, we will first run a program using static instrumentation and then with dynamic instrumentation. We plan on using an mp3 or video player. With static instrumentation, the playback will be choppy because the instrumentation will cause missed deadlines due to the high performance overhead of static instrumentation. When using dynamic instrumentation, playback is slightly choppy at first, but quickly smooths out as instrumentation is removed (and incurs no cost, once sufficient amount of the instrumentation is removed). 4. Results The first part of our results section will explain visually the difference in the static and demand-driven techniques demonstrated in the previous section.
10 Instrumentation Points Hit Over Time for mpegaudio Breakpoints Hit Sample Breakpoints/sample Static 10 per. Mov. Avg. (Breakpoints/sample) 10 per. Mov. Avg. (Static) Graph 1: Instrumentation Probes Hit Over Time (mpegaudio) Graph 1, Instrumentation Probes Hit Over Time, shows the number of instrumentation probes (called breakpoints in the graph) hit during a sample time interval when testing the program mpegaudio (with branch coverage). Static instrumentation is shown in red and our demand-driven approach with dynamic instrumentation in Jazz is shown in blue. The graph shows that the demand-driven approach nearly always executes less instrumentation. The graph also indirectly shows a comparison between the amount of overhead for each type of instrumentation. This will be explained further in the next graph. Graph 2, Jazz Branch Testing vs. Traditional Static Testing, shows a comparison between the Jazz framework and our own implementation of static instrumentation for branch coverage. The slowdown over uninstrumented code 0.98x to 1.56x (average 1.8x) which is 1.01x to 3.11x (1.63x average) times faster than the static implementation. Graph 3, Jazz Node, Branch, and Def-Use Performance, shows a comparison between the three types of structural testing the Jazz framework currently supports. The overhead associated with node testing is negligible, ranging from 0.99x to 1.04x (1.02x average). The slightly increased overhead for branch testing is due to increased complexity and the need to record more information. The slowdowns for def-use testing, ranging from 1.04x to 3.79x (2.27x average), are due to the extended lifetime of definition instrumentation. It should also be noted that these are overheads were recorded when every variable in the program was instrumented. More realistic testing, where a
11 smaller number of variables are instrumented would have a correspondingly lower overhead. Slowdown Jazz Branch Testing vs. Traditional Static Testing compress jess db javac mpegaudio mtrt jack Jazz Static Graph 2: Jazz vs. a Traditional Testing Approach (for Branch Coverage) Jazz Branch, Node, & Def-Use Performance Node Branch Def-Use Slowdown compress jess db javac mpegaudio mtrt jack Graph 3: A Comparison of Jazz s Performance on Node, Branch, & Def-Use Testing 5. Conclusion For the conclusion portion of our presentation, we will describe the contributions from implementing and using Jazz. The contributions and conclusions include:
12 1. We have created a structural testing tool, Jazz, that is both scalable and flexible. It was possible to add Node Coverage and Def-Use coverage in a short amount of time by reusing components written for Branch coverage. 2. Jazz has good performance and better enables the testing of large software projects and incorporating new test strategies. 3. Using the Eclipse GUI, an user is able to easily apply multiple testing strategies to programs. 4. Jazz has low overhead, in the best case causing no additional overhead and in the worst case having a slowdown of less than 4x. Jazz is a mature tool: The applications it can run are limited only by the Jikes RVM. 6. Availability Currently the testing GUI is implemented in Eclipse 3.0 and the test planner and dynamic instrumenter are implemented using the Jikes RVM version We plan on releasing Jazz to the compiler and software engineering community during CC 05. For more information on Jazz and demand-driven structural testing, please see University of Pittsburgh Department of Computer Science Technical Report TR or visit
Demand-Driven Structural Testing with Dynamic Instrumentation
Demand-Driven Structural Testing with Dynamic Instrumentation Jonathan Misurda, James A. Clause, Juliya L. Reed, Bruce R. Childers, and Mary Lou Soffa Department of Computer Science University of Pittsburgh
More informationInstrumentation in Software Dynamic Translators for Self-Managed Systems
Instrumentation in Software Dynamic Translators for Self-Managed Systems Naveen Kumar, Jonathan Misurda, Bruce R. Childers Department of Computer Science University of Pittsburgh Pittsburgh, PA 15260 {naveen,jmisurda,childers}@cs.pitt.edu
More informationFIST: A Framework for Instrumentation in Software Dynamic Translators
FIST: A Framework for Instrumentation in Software Dynamic Translators Naveen Kumar, Jonathan Misurda, Bruce R. Childers, and Mary Lou Soffa Department of Computer Science University of Pittsburgh Pittsburgh,
More informationJazz2: A Flexible and Extensible Framework for Structural Testing in a Java VM
Jazz2: A Flexible and Extensible Framework for Structural Testing in a Java VM Jonathan Misurda Department of Computer Science University of Pittsburgh Pittsburgh, PA 15260 jmisurda@cs.pitt.edu Bruce R.
More informationMethod-Level Phase Behavior in Java Workloads
Method-Level Phase Behavior in Java Workloads Andy Georges, Dries Buytaert, Lieven Eeckhout and Koen De Bosschere Ghent University Presented by Bruno Dufour dufour@cs.rutgers.edu Rutgers University DCS
More informationPhase-based Adaptive Recompilation in a JVM
Phase-based Adaptive Recompilation in a JVM Dayong Gu Clark Verbrugge Sable Research Group, School of Computer Science McGill University, Montréal, Canada {dgu1, clump}@cs.mcgill.ca April 7, 2008 Sable
More informationJOVE. An Optimizing Compiler for Java. Allen Wirfs-Brock Instantiations Inc.
An Optimizing Compiler for Java Allen Wirfs-Brock Instantiations Inc. Object-Orient Languages Provide a Breakthrough in Programmer Productivity Reusable software components Higher level abstractions Yield
More informationEfficiently Monitoring Data-Flow Test Coverage
Efficiently Monitoring Data-Flow Test Coverage Raul Santelices Georgia Institute of Technology College of Computing Atlanta, Georgia, USA 30332 raul@cc.gatech.edu Mary Jean Harrold Georgia Institute of
More informationMyths and Realities: The Performance Impact of Garbage Collection
Myths and Realities: The Performance Impact of Garbage Collection Tapasya Patki February 17, 2011 1 Motivation Automatic memory management has numerous software engineering benefits from the developer
More informationA Quantitative Evaluation of the Contribution of Native Code to Java Workloads
A Quantitative Evaluation of the Contribution of Native Code to Java Workloads Walter Binder University of Lugano Switzerland walter.binder@unisi.ch Jarle Hulaas, Philippe Moret EPFL Switzerland {jarle.hulaas,philippe.moret}@epfl.ch
More informationAn Evaluation of Test Coverage Tools in Software Testing
2011 International Conference on Telecommunication Technology and Applications Proc.of CSIT vol.5 (2011) (2011) IACSIT Press, Singapore An Evaluation of Test Coverage Tools in Software Testing Muhammad
More informationIntelligent Compilation
Intelligent Compilation John Cavazos Department of Computer and Information Sciences University of Delaware Autotuning and Compilers Proposition: Autotuning is a component of an Intelligent Compiler. Code
More informationEFFICIENT BRANCH AND NODE TESTING
EFFICIENT BRANCH AND NODE TESTING by Jonathan Misurda Bachelor of Science, University of Pittsburgh, 2003 Master of Science, University of Pittsburgh, 2005 Submitted to the Graduate Faculty of the Department
More informationReducing the Overhead of Dynamic Compilation
Reducing the Overhead of Dynamic Compilation Chandra Krintz y David Grove z Derek Lieber z Vivek Sarkar z Brad Calder y y Department of Computer Science and Engineering, University of California, San Diego
More informationReducing the Overhead of Dynamic Compilation
Reducing the Overhead of Dynamic Compilation Chandra Krintz David Grove Derek Lieber Vivek Sarkar Brad Calder Department of Computer Science and Engineering, University of California, San Diego IBM T.
More informationDynamic Selection of Application-Specific Garbage Collectors
Dynamic Selection of Application-Specific Garbage Collectors Sunil V. Soman Chandra Krintz University of California, Santa Barbara David F. Bacon IBM T.J. Watson Research Center Background VMs/managed
More informationLimits of Parallel Marking Garbage Collection....how parallel can a GC become?
Limits of Parallel Marking Garbage Collection...how parallel can a GC become? Dr. Fridtjof Siebert CTO, aicas ISMM 2008, Tucson, 7. June 2008 Introduction Parallel Hardware is becoming the norm even for
More informationEfficient Object Placement including Node Selection in a Distributed Virtual Machine
John von Neumann Institute for Computing Efficient Object Placement including Node Selection in a Distributed Virtual Machine Jose M. Velasco, David Atienza, Katzalin Olcoz, Francisco Tirado published
More informationEnterprise Architect. User Guide Series. Profiling
Enterprise Architect User Guide Series Profiling Investigating application performance? The Sparx Systems Enterprise Architect Profiler finds the actions and their functions that are consuming the application,
More informationEnterprise Architect. User Guide Series. Profiling. Author: Sparx Systems. Date: 10/05/2018. Version: 1.0 CREATED WITH
Enterprise Architect User Guide Series Profiling Author: Sparx Systems Date: 10/05/2018 Version: 1.0 CREATED WITH Table of Contents Profiling 3 System Requirements 8 Getting Started 9 Call Graph 11 Stack
More informationTowards Parallel, Scalable VM Services
Towards Parallel, Scalable VM Services Kathryn S McKinley The University of Texas at Austin Kathryn McKinley Towards Parallel, Scalable VM Services 1 20 th Century Simplistic Hardware View Faster Processors
More informationWHITE PAPER Application Performance Management. The Case for Adaptive Instrumentation in J2EE Environments
WHITE PAPER Application Performance Management The Case for Adaptive Instrumentation in J2EE Environments Why Adaptive Instrumentation?... 3 Discovering Performance Problems... 3 The adaptive approach...
More informationExperiences with Multi-threading and Dynamic Class Loading in a Java Just-In-Time Compiler
, Compilation Technology Experiences with Multi-threading and Dynamic Class Loading in a Java Just-In-Time Compiler Daryl Maier, Pramod Ramarao, Mark Stoodley, Vijay Sundaresan TestaRossa JIT compiler
More informationEfficient Online Computation of Statement Coverage
Efficient Online Computation of Statement Coverage ABSTRACT Mustafa M. Tikir tikir@cs.umd.edu Computer Science Department University of Maryland College Park, MD 7 Jeffrey K. Hollingsworth hollings@cs.umd.edu
More informationSABLEJIT: A Retargetable Just-In-Time Compiler for a Portable Virtual Machine p. 1
SABLEJIT: A Retargetable Just-In-Time Compiler for a Portable Virtual Machine David Bélanger dbelan2@cs.mcgill.ca Sable Research Group McGill University Montreal, QC January 28, 2004 SABLEJIT: A Retargetable
More informationDynamic Profiling & Comparison of Sun Microsystems JDK1.3.1 versus the Kaffe VM APIs
Dynamic Profiling & Comparison of Sun Microsystems JDK1.3.1 versus the VM APIs Author: Anthony Sartini Computer Engineering, Trinity College, Dublin 2, Ireland Supervisor: John Waldron Department of Computer
More informationMixed Mode Execution with Context Threading
Mixed Mode Execution with Context Threading Mathew Zaleski, Marc Berndl, Angela Demke Brown University of Toronto {matz,berndl,demke}@cs.toronto.edu (CASCON 2005, Oct 19/2005.) Overview Introduction Background:
More informationOn the Effectiveness of GC in Java
On the Effectiveness of GC in Java Ran Shaham Tel-Aviv University and IBM aifa Research aboratory rans@math.tau.ac.il Elliot K. Kolodner IBM aifa Research aboratory kolodner@il.ibm.com Mooly Sagiv Tel-Aviv
More informationDebugging Reinvented: Asking and Answering Why and Why Not Questions about Program Behavior
Debugging Reinvented: Asking and Answering Why and Why Not Questions about Program Behavior Andrew J. Ko and Brad A. Myers School of Computer Science, Carnegie Mellon University Presenter: Shaosong Li
More informationUntyped Memory in the Java Virtual Machine
Untyped Memory in the Java Virtual Machine Andreas Gal and Michael Franz University of California, Irvine {gal,franz}@uci.edu Christian W. Probst Technical University of Denmark probst@imm.dtu.dk July
More informationPhases in Branch Targets of Java Programs
Phases in Branch Targets of Java Programs Technical Report CU-CS-983-04 ABSTRACT Matthias Hauswirth Computer Science University of Colorado Boulder, CO 80309 hauswirt@cs.colorado.edu Recent work on phase
More informationIBM Research Report. Efficient Memory Management for Long-Lived Objects
RC24794 (W0905-013) May 7, 2009 Computer Science IBM Research Report Efficient Memory Management for Long-Lived Objects Ronny Morad 1, Martin Hirzel 2, Elliot K. Kolodner 1, Mooly Sagiv 3 1 IBM Research
More informationInsECTJ: A Generic Instrumentation Framework for Collecting Dynamic Information within Eclipse
InsECTJ: A Generic Instrumentation Framework for Collecting Dynamic Information within Eclipse Arjan Seesing and Alessandro Orso College of Computing Georgia Institute of Technology a.c.seesing@ewi.tudelft.nl,
More informationInsectJ: A Generic Instrumentation Framework for Collecting Dynamic Information within Eclipse
InsectJ: A Generic Instrumentation Framework for Collecting Dynamic Information within Eclipse Arjan Seesing and Alessandro Orso Georgia Institute of Technology This work was supported in part by an IBM
More informationEliminating Exception Constraints of Java Programs for IA-64
Eliminating Exception Constraints of Java Programs for IA-64 Kazuaki Ishizaki, Tatsushi Inagaki, Hideaki Komatsu,Toshio Nakatani IBM Research, Tokyo Research
More informationThe Segregated Binary Trees: Decoupling Memory Manager
The Segregated Binary Trees: Decoupling Memory Manager Mehran Rezaei Dept. of Electrical and Computer Engineering University of Alabama in Huntsville Ron K. Cytron Department of Computer Science Washington
More informationTesting Exceptions with Enforcer
Testing Exceptions with Enforcer Cyrille Artho February 23, 2010 National Institute of Advanced Industrial Science and Technology (AIST), Research Center for Information Security (RCIS) Abstract Java library
More informationDataflow testing of Java programs with DFC
Dataflow testing of Java programs with DFC Ilona Bluemke 1,, Artur Rembiszewski 1 1 Institute of Computer Science, Warsaw University of Technology Nowowiejska 15/19, 00-665 Warsaw, Poland I. Bluemke@ii.pw.edu.pl
More informationSimplifying Applications Use of Wall-Sized Tiled Displays. Espen Skjelnes Johnsen, Otto J. Anshus, John Markus Bjørndalen, Tore Larsen
Simplifying Applications Use of Wall-Sized Tiled Displays Espen Skjelnes Johnsen, Otto J. Anshus, John Markus Bjørndalen, Tore Larsen Abstract Computer users increasingly work with multiple displays that
More informationECE902 Virtual Machine Final Project: MIPS to CRAY-2 Binary Translation
ECE902 Virtual Machine Final Project: MIPS to CRAY-2 Binary Translation Weiping Liao, Saengrawee (Anne) Pratoomtong, and Chuan Zhang Abstract Binary translation is an important component for translating
More informationNLiVE Requirement Specification v. 1.0
NLiVE NLiVE Requirement Specification v. 1.0 Authors: Kevin Galloway, Nicholas Goede, James Hess, Brian Lawrence, William Mongan Class: 452 Released 2-16-2005 History Document History Version Date of Issue
More informationCoding and Unit Testing! The Coding Phase! Coding vs. Code! Coding! Overall Coding Language Trends!
Requirements Spec. Design Coding and Unit Testing Characteristics of System to be built must match required characteristics (high level) Architecture consistent views Software Engineering Computer Science
More informationApproximation of the Worst-Case Execution Time Using Structural Analysis. Matteo Corti and Thomas Gross Zürich
Approximation of the Worst-Case Execution Time Using Structural Analysis Matteo Corti and Thomas Gross Zürich Goal Worst-case execution time estimation of softreal time Java applications. We focus on semantic
More informationWHITE PAPER: ENTERPRISE AVAILABILITY. Introduction to Adaptive Instrumentation with Symantec Indepth for J2EE Application Performance Management
WHITE PAPER: ENTERPRISE AVAILABILITY Introduction to Adaptive Instrumentation with Symantec Indepth for J2EE Application Performance Management White Paper: Enterprise Availability Introduction to Adaptive
More informationContext Threading: A flexible and efficient dispatch technique for virtual machine interpreters
: A flexible and efficient dispatch technique for virtual machine interpreters Marc Berndl Benjamin Vitale Mathew Zaleski Angela Demke Brown Research supported by IBM CAS, NSERC, CITO 1 Interpreter performance
More informationSwift: A Register-based JIT Compiler for Embedded JVMs
Swift: A Register-based JIT Compiler for Embedded JVMs Yuan Zhang, Min Yang, Bo Zhou, Zhemin Yang, Weihua Zhang, Binyu Zang Fudan University Eighth Conference on Virtual Execution Environment (VEE 2012)
More informationDesign, Implementation, and Evaluation of a Compilation Server
Design, Implementation, and Evaluation of a Compilation Server Technical Report CU--978-04 HAN B. LEE University of Colorado AMER DIWAN University of Colorado and J. ELIOT B. MOSS University of Massachusetts
More informationJava On Steroids: Sun s High-Performance Java Implementation. History
Java On Steroids: Sun s High-Performance Java Implementation Urs Hölzle Lars Bak Steffen Grarup Robert Griesemer Srdjan Mitrovic Sun Microsystems History First Java implementations: interpreters compact
More informationImproving Mobile Program Performance Through the Use of a Hybrid Intermediate Representation
Improving Mobile Program Performance Through the Use of a Hybrid Intermediate Representation Chandra Krintz Computer Science Department University of California, Santa Barbara Abstract We present a novel
More informationFlexible Instrumentation for Software Dynamic Translation
Flexible Instrumentation for Software Dynamic Translation Naveen Kumar and Bruce Childers Department of Computer Science University of Pittsburgh {naveen, childers}@cs.pitt.edu http://www.cs.pitt.edu/copa
More informationRational Functional Tester - Tips and Tricks
IBM Rational Software Development Conference 2006 Rational Functional Tester - Tips and Tricks Suma Byrappa IBM Rational Swathi Rao 2006 IBM Corporation Agenda IBM Rational Software Development Conference
More informationThe Design, Implementation, and Evaluation of Adaptive Code Unloading for Resource-Constrained Devices
The Design, Implementation, and Evaluation of Adaptive Code Unloading for Resource-Constrained Devices LINGLI ZHANG and CHANDRA KRINTZ University of California, Santa Barbara Java Virtual Machines (JVMs)
More informationAdaptive Optimization using Hardware Performance Monitors. Master Thesis by Mathias Payer
Adaptive Optimization using Hardware Performance Monitors Master Thesis by Mathias Payer Supervising Professor: Thomas Gross Supervising Assistant: Florian Schneider Adaptive Optimization using HPM 1/21
More informationHierarchical PLABs, CLABs, TLABs in Hotspot
Hierarchical s, CLABs, s in Hotspot Christoph M. Kirsch ck@cs.uni-salzburg.at Hannes Payer hpayer@cs.uni-salzburg.at Harald Röck hroeck@cs.uni-salzburg.at Abstract Thread-local allocation buffers (s) are
More informationPointer Analysis in the Presence of Dynamic Class Loading
Pointer Analysis in the Presence of Dynamic Class Loading Martin Hirzel, Amer Diwan University of Colorado at Boulder Michael Hind IBM T.J. Watson Research Center 1 Pointer analysis motivation Code a =
More informationUsing Complete System Simulation to Characterize SPECjvm98 Benchmarks
Using Complete System Simulation to Characterize SPECjvm98 Benchmarks Tao Li, Lizy Kurian John, Vijaykrishnan Narayanan, Anand Sivasubramaniam, Jyotsna Sabarinathan, and Anupama Murthy Laboratory for Computer
More informationAgenda. CSE P 501 Compilers. Java Implementation Overview. JVM Architecture. JVM Runtime Data Areas (1) JVM Data Types. CSE P 501 Su04 T-1
Agenda CSE P 501 Compilers Java Implementation JVMs, JITs &c Hal Perkins Summer 2004 Java virtual machine architecture.class files Class loading Execution engines Interpreters & JITs various strategies
More informationAre you covered? New tooling for Quality Assurance
Are you covered? New tooling for Quality Assurance Edmund Reinhardt IBM i Application Development Tooling Edmund.Reinhardt@ca.ibm.com TUG TEC Agenda Key: 23C Agenda What is code coverage Code Coverage
More informationYETI. GraduallY Extensible Trace Interpreter VEE Mathew Zaleski, Angela Demke Brown (University of Toronto) Kevin Stoodley (IBM Toronto)
YETI GraduallY Extensible Trace Interpreter Mathew Zaleski, Angela Demke Brown (University of Toronto) Kevin Stoodley (IBM Toronto) VEE 2007 1 Goal Create a VM that is more easily extended with a just
More informationJust-In-Time Compilers & Runtime Optimizers
COMP 412 FALL 2017 Just-In-Time Compilers & Runtime Optimizers Comp 412 source code IR Front End Optimizer Back End IR target code Copyright 2017, Keith D. Cooper & Linda Torczon, all rights reserved.
More informationImproving Mobile Program Performance Through the Use of a Hybrid Intermediate Representation
Improving Mobile Program Performance Through the Use of a Hybrid Intermediate Representation Chandra Krintz Computer Science Department University of California, Santa Barbara Abstract Abstract. We present
More informationA Study of Cache Performance in Java Virtual Machines
A Study of Cache Performance in Java Virtual Machines by Anand Sunder Rajan, B.E., M.Sc Report Presented to the Faculty of the Graduate School of The University of Texas at Austin in Partial Fulfillment
More informationJava Performance Evaluation through Rigorous Replay Compilation
Java Performance Evaluation through Rigorous Replay Compilation Andy Georges Lieven Eeckhout Dries Buytaert Department Electronics and Information Systems, Ghent University, Belgium {ageorges,leeckhou}@elis.ugent.be,
More informationRapid Bottleneck Identification A Better Way to do Load Testing. An Oracle White Paper June 2008
Rapid Bottleneck Identification A Better Way to do Load Testing An Oracle White Paper June 2008 Rapid Bottleneck Identification A Better Way to do Load Testing. RBI combines a comprehensive understanding
More informationImproving the efficiency of adaptive middleware based on dynamic AOP
Improving the efficiency of adaptive middleware based on dynamic AOP Angela Nicoară, Johann Gyger, Gustavo Alonso Department of Computer Science Swiss Federal Institut of Technology Zürich CH-8092 Zürich,
More informationIdentifying the Sources of Cache Misses in Java Programs Without Relying on Hardware Counters. Hiroshi Inoue and Toshio Nakatani IBM Research - Tokyo
Identifying the Sources of Cache Misses in Java Programs Without Relying on Hardware Counters Hiroshi Inoue and Toshio Nakatani IBM Research - Tokyo June 15, 2012 ISMM 2012 at Beijing, China Motivation
More informationToward a definition of run-time object-oriented metrics
7TH ECOOP WORKSHOP ON QUANTITATIVE APPROACHES IN OBJECT-ORIENTED SOFTWARE ENGINEERING 200 1 Toward a definition of run-time object-oriented metrics - Position Paper - Aine Mitchell, James F. Power Abstract
More informationA Preliminary Workload Analysis of SPECjvm2008
A Preliminary Workload Analysis of SPECjvm2008 Hitoshi Oi The University of Aizu January 24, 2009 International Conference on Computer Engineering and Technology 2009 Outline Introduction: SPECjvm2008
More informationCoverage Criteria for GUI Testing. Research focus
1 Coverage Criteria for GUI Testing Atif M. Memon*, Mary Lou Soffa,, Martha E. Pollack atif@cs cs.umd..umd.edu Dept. of Computer Science University of Pittsburgh *now at the University of Maryland Research
More informationeswt Requirements and High-Level Architecture Abstract Document Information Change History
eswt Requirements and High-Level Architecture Abstract There is a need for a standardized UI API fit for embedded devices having fewer resources and smaller screen sizes than a desktop computer. The goal
More informationThe VMKit project: Java (and.net) on top of LLVM
The VMKit project: Java (and.net) on top of LLVM Nicolas Geoffray Université Pierre et Marie Curie, France nicolas.geoffray@lip6.fr What is VMKit? Glue between existing VM components LLVM, GNU Classpath,
More informationA Trace-based Java JIT Compiler Retrofitted from a Method-based Compiler
A Trace-based Java JIT Compiler Retrofitted from a Method-based Compiler Hiroshi Inoue, Hiroshige Hayashizaki, Peng Wu and Toshio Nakatani IBM Research Tokyo IBM Research T.J. Watson Research Center April
More informationPointer Analysis in the Presence of Dynamic Class Loading. Hind Presented by Brian Russell
Pointer Analysis in the Presence of Dynamic Class Loading Martin Hirzel, Amer Diwan and Michael Hind Presented by Brian Russell Claim: First nontrivial pointer analysis dealing with all Java language features
More informationReducing Generational Copy Reserve Overhead with Fallback Compaction
Reducing Generational Copy Reserve Overhead with Fallback Compaction Phil McGachey Antony L. Hosking Department of Computer Sciences Purdue University West Lafayette, IN 4797, USA phil@cs.purdue.edu hosking@cs.purdue.edu
More informationCoverage Criteria for GUI Testing. Research focus. GUI Test Case. Sequence of Events. Not just individual events
1 Coverage Criteria for GUI Testing Atif M. Memon*, Mary Lou Soffa,, Martha E. Pollack atif@cs cs.umd..umd.edu Dept. of Computer Science University of Pittsburgh *now at the University of Maryland Research
More informationAlgorithms: Design & Practice
Algorithms: Design & Practice Deepak Kumar Bryn Mawr College Spring 2018 Course Essentials Algorithms Design & Practice How to design Learn some good ones How to implement practical considerations How
More informationProgram Analysis. Program Analysis
Program Analysis Class #4 Program Analysis Dynamic Analysis 1 Static VS Dynamic Analysis Static analysis operates on a model of the SW (without executing it) If successful, produces definitive information
More informationJava without the Coffee Breaks: A Nonintrusive Multiprocessor Garbage Collector
Java without the Coffee Breaks: A Nonintrusive Multiprocessor Garbage Collector David F. Bacon IBM T.J. Watson Research Center Joint work with C.R. Attanasio, Han Lee, V.T. Rajan, and Steve Smith ACM Conference
More informationFunctional verification on PIL mode with IAR Embedded Workbench
by Cristina Marconcini, STM CASE s.r.l. Functional verification on PIL mode with IAR Embedded Workbench The increase of complexity of embedded system components combined with time-to-market constraints
More informationMotivation was to facilitate development of systems software, especially OS development.
A History Lesson C Basics 1 Development of language by Dennis Ritchie at Bell Labs culminated in the C language in 1972. Motivation was to facilitate development of systems software, especially OS development.
More informationL.C.Smith. Privacy-Preserving Offloading of Mobile App to the Public Cloud
Privacy-Preserving Offloading of Mobile App to the Public Cloud Yue Duan, Mu Zhang, Heng Yin and Yuzhe Tang Department of EECS Syracuse University L.C.Smith College of Engineering 1 and Computer Science
More information5th World Congress for Software Quality Shanghai, China November 2011
Yoshihiro Kita University of Miyazaki Miyazaki, Japan kita@earth.cs.miyazaki-u.ac.jp Proposal of Execution Paths Indication Method for Integration Testing by Using an Automatic Visualization Tool Avis
More informationP17 System Testing Monday, September 24, 2007
IBM Software Group P17 System Testing Monday, September 24, 2007 Module 8 : IBM Rational Testing Solutions Marty Swafford IBM Rational Software IBM Certified Solution Designer - Rational Manual Tester,
More informationJULIA ENABLED COMPUTATION OF MOLECULAR LIBRARY COMPLEXITY IN DNA SEQUENCING
JULIA ENABLED COMPUTATION OF MOLECULAR LIBRARY COMPLEXITY IN DNA SEQUENCING Larson Hogstrom, Mukarram Tahir, Andres Hasfura Massachusetts Institute of Technology, Cambridge, Massachusetts, USA 18.337/6.338
More informationUSING JAVA HARTSTONE BENCHMARK IN A REAL-TIME SYSTEMS COURSE
USING JAVA HARTSTONE BENCHMARK IN A REAL-TIME SYSTEMS COURSE Andy Ju An Wang 1 Abstract This paper shows how a Java benchmark program can be utilized in a real-time systems course to emphasize fundamental
More informationAn Introduction to Runtime Analysis with Rational PurifyPlus
Copyright Rational Software 2002 http://www.therationaledge.com/content/dec_02/t_runtimepurifyplus_gb.jsp An Introduction to Runtime Analysis with Rational PurifyPlus by Goran Begic Technical Marketing
More informationThe Z Garbage Collector Low Latency GC for OpenJDK
The Z Garbage Collector Low Latency GC for OpenJDK Per Lidén & Stefan Karlsson HotSpot Garbage Collection Team Jfokus VM Tech Summit 2018 Safe Harbor Statement The following is intended to outline our
More informationUsing Annotations to Reduce Dynamic Optimization Time
In Proceedings of the SIGPLAN Conference on Programming Language Design and Implementation (PLDI), June 2001. Using Annotations to Reduce Dynamic Optimization Time Chandra Krintz Brad Calder University
More informationInteraction of JVM with x86, Sparc and MIPS
Interaction of JVM with x86, Sparc and MIPS Sasikanth Avancha, Dipanjan Chakraborty, Dhiral Gada, Tapan Kamdar {savanc1, dchakr1, dgada1, kamdar}@cs.umbc.edu Department of Computer Science and Electrical
More information6.UAP Final Report: Replication in H-Store
6.UAP Final Report: Replication in H-Store Kathryn Siegel May 14, 2015 This paper describes my research efforts implementing replication in H- Store. I first provide general background on the H-Store project,
More informationITERATIVE DEVELOPMENT: THE USE OF J2EE BEST PRACTICES
TUTORIAL: WHITE PAPER VERITAS Indepth for the J2EE Platform ITERATIVE DEVELOPMENT: THE USE OF J2EE BEST PRACTICES By Owen Taylor Of The Middleware Company 1 1. Overview... 3 2. Selecting Appropriate Tools...
More informationAutomatic Object Colocation Based on Read Barriers
See discussions, stats, and author profiles for this publication at: https://www.researchgate.net/publication/221644818 Automatic Object Colocation Based on Read Barriers Conference Paper September 2006
More informationTools to Develop New Linux Applications
Tools to Develop New Linux Applications IBM Software Development Platform Tools for every member of the Development Team Supports best practices in Software Development Analyst Architect Developer Tester
More informationUsing Java for Scientific Computing. Mark Bul EPCC, University of Edinburgh
Using Java for Scientific Computing Mark Bul EPCC, University of Edinburgh markb@epcc.ed.ac.uk Java and Scientific Computing? Benefits of Java for Scientific Computing Portability Network centricity Software
More informationSCALING UP VS. SCALING OUT IN A QLIKVIEW ENVIRONMENT
SCALING UP VS. SCALING OUT IN A QLIKVIEW ENVIRONMENT QlikView Technical Brief February 2012 qlikview.com Introduction When it comes to the enterprise Business Discovery environments, the ability of the
More informationThe Z Garbage Collector An Introduction
The Z Garbage Collector An Introduction Per Lidén & Stefan Karlsson HotSpot Garbage Collection Team FOSDEM 2018 Safe Harbor Statement The following is intended to outline our general product direction.
More informationHeimdall Data Access Platform Installation and Setup Guide
Heimdall Data Access Platform Installation and Setup Guide Heimdall Data Access Platform Installation and Setup Guide Heimdall Data Access Platform Installation and Setup Guide 1. General Information 1
More informationReconfigurable Architecture Requirements for Co-Designed Virtual Machines
Reconfigurable Architecture Requirements for Co-Designed Virtual Machines Kenneth B. Kent University of New Brunswick Faculty of Computer Science Fredericton, New Brunswick, Canada ken@unb.ca Micaela Serra
More informationTowards future method hotness prediction for Virtual Machines
Towards future method hotness prediction for Virtual Machines Manjiri A. Namjoshi Submitted to the Department of Electrical Engineering & Computer Science and the Faculty of the Graduate School of the
More informationJava for Programmers Course (equivalent to SL 275) 36 Contact Hours
Java for Programmers Course (equivalent to SL 275) 36 Contact Hours Course Overview This course teaches programmers the skills necessary to create Java programming system applications and satisfies the
More information