Performance analysis of an XForms framework with the main focus on profiling by example of Chiba

Table of Contents

1. Performance & Profiling

1.1. Performance

1.2. Performance in the Software Development Life Cycle

1.3. Profiling

2. Methods

2.1. Modelling Approach

2.2. Measurement Approach

2.3. Testing

2.3.1. Volume Testing

2.3.2. Stress Testing

2.3.3. Performance Testing

2.4. Benchmarking

2.5. Monitoring

2.5.1. J2EE Management Specification (JSR-77)

2.5.2. Java Management Extension (JMX)

2.6. Exhaustive Analysis

2.7. Hotspot Analysis Approach

2.8. Exploring the Domain

2.8.1. Community

2.8.2. Third Parties

2.8.3. Master Performance Report

2.9. Verify & Validate

2.9.1. Java Virtual Machine (JVM)

2.9.2. Final JVM Annotations

2.10. Tuning Approach

2.10.1. Common Tuning Pitfalls

2.11. Conclusion

3. XForms / Chiba Fundamentals

3.1. XForms

3.2. Chiba

3.2.1. Chiba Sandbox – The Core

3.2.2. Chiba Web – The Main Distribution

3.3. Conclusion

4. Performance Analysis Iteration

4.1. Utilised System

4.2. Profiling Tools Put into Service

4.2.1. EtmMonitor – Java Execution Time Measurement Library

4.2.2. AspectWerkz – Lightweight Java Code Profiler

4.2.3. YourKit Java Profiler – Comprehensive Code and Memory Profiler

4.2.4. Clover – Comprehensive Java Coverage Testing

4.3. Acquiring Information about Chiba

4.3.1. Community Driven

4.3.2. Third Party Driven

4.4. Verify Hypothesis About Hotspots

4.4.1. Hotspot 1 - Chiba Session

4.4.2. Hotspot 2 - JAXP Document Creation

4.4.3. Hotspot 3 – XForms Actions

4.5. XForms Test Bundles

4.6. Test Setup

4.6.1. Requirements

4.6.2. Infrastructure

4.6.3. Webtest

4.6.4. Handicaps

4.7. Verify Hypothesis About Hotspots 3 - XForms Actions

4.7.1. First Attempt

4.7.2. Second Attempt

4.7.3. Unscripted Mode Profiling

4.7.4. Scripted Mode Profiling

4.7.5. Verify Profiled Data

5. Tuning XForms Actions

5.1. Tuning preparations

5.2. Analyse Bottleneck

5.3. Confute Hypothesis

5.4. The Tuning Process

5.4.1. Tuning Iteration 1 – Next Generation Refresh

5.4.2. Tuning Iteration 2 – ModelItem

5.4.3. Tuning Iteration 3 – Inserted ModelItems

5.4.4. Tuning Iteration 4 – UI Element State

5.4.5. Tuning Iteration 5 – Output Control

5.4.6. Tuning Iteration 6 – Referencing Non Existing ModelItems

5.5. Prove Enhancement

5.5.1. Small Instance Data

5.5.2. Medium Large Instance

5.5.3. Very Big Instance Data / Repeat

5.6. Finale

6. Closing

Objectives & Core Themes

The primary objective of this thesis is to identify and resolve performance inadequacies within the Chiba XForms framework. By applying a structured hotspot analysis, the author investigates how efficient profiling and performance testing can be implemented to pinpoint bottlenecks, particularly within the XForms engine's core mechanisms.

• Performance profiling methodologies within Java-based architectures.
• Evaluation of automated performance testing and measurement infrastructures.
• Identification of hotspots in XForms processing, specifically regarding event sequencing and Model refresh cycles.
• Implementation and validation of performance-enhancing refactoring for XForms core components.
• Comparative analysis of scripted vs. unscripted mode performance in distributed environments.

Excerpt from the Thesis

Summary of Chapters

Performance & Profiling: Explores theoretical foundations of performance metrics, benchmarking, and the significance of profiling within the software development life cycle.

Methods: Details various performance modelling and measurement approaches, emphasizing a structured hotspot analysis workflow.

XForms / Chiba Fundamentals: Introduces the technical background of the XForms specification and the architecture of the Chiba framework.

Performance Analysis Iteration: Documents the practical application of automated performance tests to detect bottlenecks in Chiba's core processing.

Tuning XForms Actions: Describes the iterative refactoring process to optimize the xforms-refresh and rebuild mechanisms, proving performance enhancements through re-testing.

Closing: Concludes the thesis by reviewing the analysis outcomes and confirming the successful optimization of the framework.

Keywords

XForms, Chiba, Performance Profiling, Software Optimization, Bottleneck Analysis, Java Performance, Hotspot Analysis, Automated Testing, Servlet Container, DOM, JSR-77, JMX, Software Development Life Cycle, Benchmarking, Scalability.

Frequently Asked Questions

What is the core focus of this research?

The research focuses on the performance analysis and optimization of the Chiba XForms framework. The main goal is to identify why certain XForms actions exhibit performance degradation and to implement targeted fixes.

Which primary methodology is employed for performance improvement?

The author uses an iterative hotspot analysis approach, based on the Pareto principle (80/20 rule), to systematically find, verify, and resolve performance bottlenecks.

What are the central challenges in profiling XForms frameworks?

Key challenges include distinguishing between framework-specific overhead and application-level inefficiencies, as well as the complexity of Java environment factors like JVM warmup and garbage collection.

How is the automated test infrastructure structured?

The infrastructure uses Maven for build management, TestNG for executing test suites, and Selenium for simulating user behavior in browsers, all integrated within a headless automated process.

What specific bottlenecks were identified in the Chiba framework?

Significant bottlenecks were found in the Model.refresh() mechanism and the Model.rebuild() function, which caused inefficient iteration over the host document during event processing.

What were the measurable results of the tuning process?

The tuning effort led to significant performance gains, with some operations (like the setvalue action) becoming up to 160 times faster in specific test scenarios compared to the original implementation.

How does unscripted mode differ from scripted mode in Chiba's performance?

Unscripted mode involves re-creating the entire application state on the server for each action, which contributes significantly to performance overhead compared to the more granular updates possible in scripted mode.

What role does the JSR-77 specification play in this work?

JSR-77 and JMX are utilized as the underlying standards for monitoring the performance metrics of the managed Java objects within the framework environment.