The document discusses performance anti-patterns that can occur when using object-relational mapping (ORM) frameworks. It presents a framework for detecting and ranking performance anti-patterns based on their impact. One example anti-pattern is retrieving excessive data from the database that is never used. The framework detects this by analyzing data usage and checking if retrieved data is ever accessed. Experiments on open-source systems show this anti-pattern can be detected and fixing it improves performance significantly with medium to large effect sizes. The ranks of anti-patterns are also consistent across different data scales.

1. Detecting Performance Anti-patterns for
Applications Developed Using
Object-Relational Mapping
1
Mohamed Nasser, Parminder Flora
Tse-Hsun(Peter) Chen Ahmed E. HassanWeiyi Shang Zhen Ming Jiang

2. Databases are essential in large-scale
software systems
2
Database

3. 3
Application developers work with objects
More intuitive if we can
map objects directly to DB

4. 4
Object-Relational Mapping eliminates
the gap between objects and SQL
Database
• Lots of boilerplate code
• Need to manage object-DB
translations manually
Object
Classes
Problem of using raw SQLs
ORM
Much less code and shorter
development time

5. ORM is widely used in practice
5
• Java Hibernate has more than 8
million downloads
• In 2013, 15% of the 17,000 Java
developer jobs require ORM
experience (dice.com)
Different ORM technologies

6. An example class with ORM code
6
@Entity
@Table(name = “user”)
public class User{
@Column(name=“id”)
private int id;
@Column(name=“name”)
String userName;
@OneToMany(fetch=FetchType.EAGER)
List<Team> teams;
public void setName(String n){
userName = n
}
… other getter and setter methods
User.javaUser class is
mapped to “user”
table in DB
id is mapped to the
column “id” in the
user table
A user can belong
to multiple teams
Eagerly retrieve
associated teams
when retrieving a
user object

7. Accessing the database using ORM
7
User u = findUserByID(1);
ORM
database
select u from user
where u.id = 1;
u.setName(“Peter”);
update user set
name=“Peter”
where user.id = 1;
Objects SQLs

8. Developers may not be aware of
database access
Wow! I don’t
need to worry
about DB code!
ORM code with
performance anti-patterns
8
Bad system
performance
The performance difference can be LARGE!

9. Performance anti-pattern
detection framework
Performance anti-pattern detection and
ranking framework
Ranked according to
performance impact
Ranked
Performance
anti-patterns
Source
Code
detection
ranking
9

10. Performance anti-pattern
detection framework
Performance anti-pattern detection and
ranking framework
Ranked according to
performance impact
Ranked
Performance
anti-patterns
Source
Code
detection
ranking
10
Discuss only one anti-pattern
in the presentation
(more patterns in the paper)

11. ORM excessive data anti-pattern
Class User{
@EAGER
List<Team> teams;
}
User u = findUserById(1);
u.getName();
EOF
11
Objects
SQL
Eagerly retrieve
teams from DB
User Table Team Table
join Team data is never
used!

12. Detecting excessive data
using static analysis
12
First find all the objects that
eagerly retrieve data from DB
Class User{
@EAGER
List<Team> teams;
}
Identify all the data usages of
objects
User user = findUserByID(1);
Check if the retrieved data is ever
used
user.getName();
user team
user team

13. Performance anti-pattern
detection framework
Performance anti-pattern detection and
ranking framework
Ranked according to
performance impact
Ranked
Performance
anti-patterns
Source
Code
detection
ranking
13

14. Performance anti-pattern
detection framework
Performance anti-pattern detection and
ranking framework
Ranked according to
performance impact
Ranked
Performance
anti-patterns
Source
Code
detection
ranking
14

15. Performance anti-patterns have
different impacts
15
User user_in_1_team = findUserByID(1);
Retrieving 1 user and 1 team
User user_in_100_teams = findUserByID(100);
Retrieving 1 user and 100 teams!
One can only reveal performance
impact by execution

16. Measuring the impact using repeated
measurements and effect sizes
16
We use effect sizes (Cohen’s D) to measure
the performance impact
Effect sizes =
We repeat each test 30 times to obtain stable
measurement results
Size of performance impact is not defined:
Performance measurements are unstable:

17. Studied systems and detection results
Large open-source
e-commence system
> 1,700 files
> 206K LOC
Enterprise system
> 3,000 files
> 300K LOC
Spring open-source system
Online system for a pet clinic
51 files
3.3K LOC
482 excessive data > 10 excessive data 10 excessive data
17

18. Performance impact
Research questions
Ranks of the anti-patterns at
different scales
18

19. Performance impact
Research questions
Ranks of the anti-patterns at
different scales
19

20. Assessing anti-pattern impact by
fixing the anti-patterns
Execution
Response timeuser.getName()
Code with
anti-patterns
fetchType.set(LAZY)
user.getName()
Code without
anti-patterns
20
Execute test
suite 30 times
Response time
after fixing the
anti-patterns
Avg. %
improvement and
effect sizes
Execution
Execute test
suite 30 times

21. Performance anti-patterns have
medium to large effect sizes
0%
20%
40%
60%
80%
100%
Excessive Data
BL
EA
PC
21
%improvementinresponsetime
large
effect size
large
effect size medium
effect size

22. Performance impact
Research questions
Ranks of the anti-patterns at
different scales
22
Removing anti-pattern
improves response by ~35%

23. Performance impact
Research questions
Ranks of the anti-patterns at
different scales
23
Removing anti-pattern
improves response by ~35%

24. Performance problems usually arise
under large load
24

25. Performance problems revealed at
small scales may be more serious
25
We should first fix the anti-patterns that
have larger effects at smaller scales
Input scales may have
exponential effects on
performance
Different input scales Performance at
different input scales

26. Comparing ranked anti-patterns at
different data scales
26
Ranked
Performance
anti-patterns
from small data
detection
ranking
Ranked
Performance
anti-patterns
from large data
?
Small size input
Large size input

27. Anti-patterns have large effects on
performance even at smaller data scales
27
0
10
20
30
40
50
0
1
2
3
4
5
Effectsize
Effect sizes and the ranks of the anti-patterns
are consistent in different data scales

28. Performance impact
Research questions
Ranks of the anti-patterns at
different scales
28
Removing anti-pattern
improves response by ~35%
Ranks of the anti-patterns
are consistent in different
data scales

29. 29

30. 30

31. 31

32. 32

33. 33
tsehsun@cs.queensu.ca