Static Analysis in Search of Performance Anti-Patterns

Patrycja WegrzynowiczFounder and CTO, Yonita Inc.Founder and CTO, Yon Labs and Yon Consulting

About me

Past• 10+ years of professional experience as software developer, architect,

and head of software R&D

• PhD in Computer Science (automated code analysis)

• Speaker at JavaOne, JavaZone, ASE, OOPSLA, Jazoon, and others

Present• Founder and CTO of Yonita Inc., Yon Labs, and Yon Consulting

• Bridge the gap between the industry and the academia

Future• Who cares? Seize the day!

Agenda

Performance issues• Performance bottlenecks and how to deal with them

Automated code analysis• Semantic code query system

Performance anti-patterns• Code samples

• Code queries

PERFORMANCE ISSUES

This is Java.

Is Java slow?

On most Intels Java is as fast or faster than C• The Gaia Satellie and Data Processing

• William O’Mullane from European Space Astronomy Centre

• Jazoon 2010

Limited Resources

Hardware

OS

Application

Locks

Pools

FD

Threads

Network Processors

RAM HD

Memory

Sun’s SDK, Arrays.binarySearch, Joshua Bloch

The Way We Write Software

Business

Requirements

Technology Stack

Software Teams

JSF

JPA

hibernate

struts Tapestr

y

iBatis

JTA

EJB

RMI

GWTSwing

JSP

JMS

awt

JNDI

JDO

Performance Issues

Root causes• Bad architecture, design, or code

• Wrong configuration (app/db server, OS, RDBMS)

• Rarely insufficient hardware

Bottlenecks usually unnoticed until happen• Special conditions to happen: size of data, number of users

• The later discovered the more expensive to solve

Performance Tuning

MIF cycle

Dynamic analysis

• Log/traces

• Profiles

Environments

• Testing

• Production

Monitor

Identify

Fix

Our Code

A Single Spaghetti is Hard to See

(Anti-)Patterns in Our Spaghetti

Automated Code Performance Tuning

+

Automated code analysis

Definions of performance anti-patterns

Detection of Performance Anti-Patterns

Benefits• Hints on performance on higher level of abstraction (architecture,

design, programming constructs) instead of in terms of lower level

concepts (CPU usage, memory consumptions etc.)

• Supports developers and development phase

• Promotes best practices (refactored solutions)

Problems• Lack of formalization, high-level concepts, textual description

• Implementation variants

• Size of code

AUTOMATED CODE ANALYSIS

Think? Why think! We have computers to do that for us.

– Jean Rostand

Semantic Code Query System

Code query systems• Explore relationships among program elements

• Structural and call-related predicates

• CodeQuest, JQuery

Semantic code query systems• Focus on behavior (in-depth data flow analysis)

• Behavioral predicates in addition to structural ones

• D-CUBED – my PhD thesis (focus on design patterns)

• Yonita – rewrite + queries

How does Yonita work?

Analyses

Parser

Store

Query

Bytecodeor

Sources

Asm/Recoder

analyses: structural, call flow, data flowtransitive closures relational (MySQL) or

deductive (XSB) database

SQL or Prolog(anti-)patternsbugsvulnerabilities...

Metamodel

Structural elements• Very similar to CodeQuest and Jquery

• Statements

Instances• Symbolic instances

Behavioral predicates supporting call and data flows• Output and input values

• Assignments

Instances

Null

New

This

Parameter

Exception

Multiple

ReturnInstance

ParamInstance

ThisInstance

NewInstance

NullInstance

Except.Instance

Instance Instance …

Instance … Instance …

Behavioral Predicates

Calls• makesCallConditionally(Callable, Callable)

• makesCallAlways(Callable, Callable)

Input and output values• hasInput(Callable, Instance)

• hasInput(Statement, Instance)

• hasOutput(Callable, Instance)

• hasOutput(Statement, Instance)

Assignments• assigns(Field, Instance)

Running Yonita Prototype

Run Yonita to parse an application• yonita [classes] [libs] –prolog –mysql

MySQL configuration• hibernate.cfg.xml

• Run MySQL console and ask queries (SQL)

Prolog configuration• -Dprolog.file=output.P -prolog=output.P

• Run XSB Prolog console and ask queries (Prolog)

Yonita on Google App Engine• In progress

PERFORMANCE ANTI-PATTERNS

Redundant Work – Example 1 (Web)

Redundant Work – Example 1 (Web)

Multiple calls to

database (7 calls!)

Multiple security

check

• Each call to getUser

checks permissions

What if getUser were

a remote method?!

1 call 5 calls 10 calls 50 calls 100 calls

getUser 4 21 42 161 330

getUser checks per-missions

24 118 239 1111 2222

getUser re-mote

31 172 338 1663 3404

250

1250

2250

3250

Chart Title

Axis Title

Redundant Work – Example 2 (agilefant)

Redundant Work – Example 2 (agilefant)

Redundant Work – Example 2 (agilefant – sourceforge project)

Thank you hibernate!Open Session in View

Session cache

Redundant Work – Example 3 (agilefant)

AJAX Calls

Redundant Work – Example 3 (agilefant)

AJAX Calls

Redundant Work – Example 3 (agilefant)

AJAX Calls

Redundant Work

Description• A time-consuming method is

called many times on a single

execution path

Consequences• A slower execution time

Refactored solution• Call the heavy method only once

and store the result for further re-

use

Heavy

Heavy

Heavy

Redundant Work – Code Query

redundantWork(X, Heavy) :-

// method Heavy called at least twice...

method(X), method(Heavy),

isHeavy(Heavy),

hasChild(X, Invocation1), methodInvocation(Invocation1, Heavy),

hasChild(X, Invocation2), methodInvocation(Invocation2, Heavy),

// ...with the same parameters

setof(I1, (hasInput(Invocation1, newInstance(I1)), All),

setof(I2, (hasInput(Invocation2, newInstance(I2)), All).

isHeavy(X) :- isWebService(X).

isHeavy(X) :- isDatabaseService(X).

Fine Grained Remote Calls

Entity Beans

• EJB1

• EJB2

Remote Calls

• Remote calls have

significant impact on

application

performance

ClientBean

getX()

getY()

getZ()

One by One Processing – Example 1

Add users to a group

• Performed in the web

layer one by one

• Multiple calls to the

service layer

• Multiple loads and

updates each in a

separate transaction!

• Multiple authorization!

One by One Processing – Example 2

Delete a group

• Detach a group from

every user in a group

one by one

One by One Processing

Description• The objects in a collection are

processed one by one and a

single processing requires a call

to a time-consuming method (e.g.

database access, remote call)

Consequences• A significant increase in time with

the increase of collection size

Refactored solution• Consider batch processing

Heavy

Heavy

Heavy

Heavy

Unused Object – Example (richfaces 3.2.2)

Unused Object

Description• An object created (usually

retrieved from a database),

passed to further methods

(usually a long chain of method

calls), and than not used

Consequences• Higher memory consumption that

may lead to performance issues

Refactored solution• Create objects only if you need

them.

Unused Objects – Hibernate Mapping

Unused Objects - Standard Collection Mapping

Unused Objects - Immutable Collection

Summary

We need to write better code!

Performance anti-patterns• High-level concepts

• Many implenentation variants

Static analysis can help in discovery of performance

issues• Useful tool but it does not replace a traditional approach to

performance tuning (measure, identify, fix)

Contact

Patrycja• patrycja@YonLabs.com

• twitter.com/YonLabs

Yonita• http://www.Yonita.com

• http://www.YonLabs.com

• http://www.YonConsulting.com