Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.

ICSE2014 - Detecting Performance Anti-patterns for Applications Developed using Object-Relational Mapping

610 views

Published on

Object-Relational Mapping (ORM) provides developers a conceptual abstraction for mapping the application code to the underlying databases. ORM is widely used in industry due to its convenience; permitting developers to focus on developing the business logic without worrying too much about the database access details. However, developers often write ORM code without considering the impact of such code on database performance, leading to cause transactions with timeouts or hangs in large-scale systems. Unfortunately, there is little support to help developers automatically detect suboptimal database accesses. In this paper, we propose an automated framework to detect ORM performance anti-patterns. Our framework automatically flags performance anti-patterns in the source code. Furthermore, as there could be hundreds or even thousands of instances of anti-patterns, our framework provides sup- port to prioritize performance bug fixes based on a statistically rigorous performance assessment. We have successfully evaluated our framework on two open source and one large-scale industrial systems. Our case studies show that our framework can detect new and known real-world performance bugs and that fixing the detected performance anti- patterns can improve the system response time by up to 98%.

Published in: Software, Technology
  • Be the first to comment

ICSE2014 - Detecting Performance Anti-patterns for Applications Developed using Object-Relational Mapping

  1. 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. 2. Databases are essential in large-scale software systems 2 Database
  3. 3. 3 Application developers work with objects More intuitive if we can map objects directly to DB
  4. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 18. Performance impact Research questions Ranks of the anti-patterns at different scales 18
  19. 19. Performance impact Research questions Ranks of the anti-patterns at different scales 19
  20. 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. 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. 22. Performance impact Research questions Ranks of the anti-patterns at different scales 22 Removing anti-pattern improves response by ~35%
  23. 23. Performance impact Research questions Ranks of the anti-patterns at different scales 23 Removing anti-pattern improves response by ~35%
  24. 24. Performance problems usually arise under large load 24
  25. 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. 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. 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. 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. 29
  30. 30. 30
  31. 31. 31
  32. 32. 32
  33. 33. 33 tsehsun@cs.queensu.ca

×