Transcript Storage Decisions 2003

Static Analysis in Search of
Performance Anti-Patterns
Patrycja Wegrzynowicz
Founder 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
Locks
Pools
Application
Memory
FD
OS
Threads
Network
Processors
Hardware
RAM
HD
Sun’s SDK, Arrays.binarySearch, Joshua Bloch
The Way We Write Software
Business
strut
JS
aw
s
P GWT Tapestr
t
Swin
y
g
JSF
RM
I EJ
JND JMS
JT
B
I
A iBati JPA
hibernate
s JD
O
Requirements
Technology Stack
Software Teams
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
Fix
Monitor
•
•
Log/traces
Profiles
Environments
Identify
•
•
Testing
Production
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
Think? Why think! We have computers to do that for us.
– Jean Rostand
AUTOMATED CODE ANALYSIS
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?
Bytecode
or
Sources
SQL or Prolog
(anti-)patterns
bugs
vulnerabilities
...
Asm/Recoder
Parser
Query
Analyses
analyses: structural,
call flow, data flow
transitive closures
Store
relational (MySQL) or
deductive (XSB) database
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
Return
Instance
This
Instance
Param
Instance
New
Instance
Except.
Instance
Null
Instance
Instance Instance
…
Exception
Multiple
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?!
Axis Title
Chart Title
4000
3500
3000
2500
2000
1500
1000
500
0
getUser
getUser checks
permissions
getUser remote
1 call
4
5 calls
21
10 calls
42
50 calls
161
100 calls
330
24
118
239
1111
2222
31
172
338
1663
3404
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
Heavy
Consequences
•
Heavy
A slower execution time
Refactored solution
•
Call the heavy method only once
and store the result for further re-
Heavy
use
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
•
•
getX()
Client
getY()
getZ()
Bean
EJB1
EJB2
Remote Calls
•
Remote calls have
significant impact on
application
performance
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)
Heavy
Consequences
Heavy
Heavy
•
Heavy
A significant increase in time with
the increase of collection size
Refactored solution
•
Consider batch processing
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
• [email protected]
• twitter.com/YonLabs
 Yonita
• http://www.Yonita.com
• http://www.YonLabs.com
• http://www.YonConsulting.com