Test environment

I used Apache JMeter to create load tests. They were run against the latest version of XPlanner with upgraded copy of the production database

On staging machine (toolsstaging1)

Tomcat:

Version: 5.0.28

Memory options: -Xms768M -Xmx1280M

Run as a java process with JProfiler additions

MySQL

Version: 4.0.26

Standard configuration but max_allowed_packet=1024M

Run as a Windows service.

On my application

• Apache JMeter v2.1.1
• JProfiler GUI v4.1.3
• MySQL Administrator 1.1.9

The tested application had been deployed on toolsstaging1. JProfiler's additions collected all information about method invocations and published it on a TCP port. The GUI part, installed on my local machine gathered the data and showed in the JProfiler window.

Test

I created two kind of tests was creaded. The simulation of iteration planning and trying to reproduce the regular using of XPlanner. The tests consisted of the steps shown below:

Test results before optimization

The following tables contain test results for every page involved in a given test.

The percentage column shows how much time given element (page or method) was run in a given context. For a page the total time is execution of all pages, for a method it is execution of a page the method is called from.

The tables contain all pages executed by the test. Only those methods are shown for which execution time was bigger than 10% of the execution of overall page.

Optimization

The most time consuming methods are those connected with authorization. Below are the tunning steps I did to speed up the application:

• add a binary column to indicate if permission is positive or negative. So far the negative permissions had a minus sign as a prefix of permission name. That solution complicated queries to get the permissions from the database and also determining if the permission is negative or positive required string operations, which are more time consuming that the binary ones.
• The query to get all permission for all people was getting both person-specific permissions and role based permission in one go. That caused that the query was really complex and time consuming. I rewrote it to create two queries; one to get person specific permission and the other one to get role based permission. This solution speeded up the queries about 4 times.
• The factor which slowed down the application the most was inefficient permission caching framework. The cache for permissions for all people was invalidated after every logout. The refactoring I did was to separate the authorizer login from the caching. I use AOP for that. I extracted two beans from AuthorizerImpl; PermissionQueryHelper and PersonPermissionHelper. Those beans are responsible for getting permission from the database; respectively all permission for all people and permissions for a given person only. Using AOP I created advisors for that beans; those advisors are checking if the cache already contains the return value for a cached method; if does the original method is not called but the cached value is returned. If the cache doesn't contain the results, the method is called and the result, before it is returned to the caller, is put into cache. Other advisors were created to invalidate the cache. There are two joinpoints when the cache can is invalidated:
  • Authenticator.logout() - the person specific cache
  • EditPersonHelper.modifyRoles() - all caches

Test results after optimization