1 / 19

Detecting Inefficiently-Used Containers to Avoid Bloat

This paper discusses the detection of inefficiently used containers in Java applications to prevent runtime bloat and optimize memory usage. It presents a combination of static and dynamic analysis techniques to identify underutilized and overpopulated containers.

faulknerw
Download Presentation

Detecting Inefficiently-Used Containers to Avoid Bloat

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Detecting Inefficiently-Used Containers to Avoid Bloat Guoqing Xuand Atanas Rountev Department of Computer Science and Engineering Ohio State University

  2. Container Bloat • Pervasively used in large Java applications • Many types and implementations in JDK libraries • User-defined container types • Container inefficiency becomes a significant source of runtime bloat • Many memory leak bugs reported in the Sun Java bug database are caused by misuse of containers [Xu-ICSE’08] • Optimizing a misused HashMap reduced the number of created objects by 66%[Xu-PLDI’09]

  3. The Targeted Container Inefficiencies • Underutilized container – from jflex Vector v = new Vector(); v.addElement(new Interval(’\n’,’\r’)); v.addElement(new Interval(’\u0085’,’\u0085’)); RegExp1 c = new RegExp1(sym.CCLASS, v); … • Overpopulated container – from muffin Map getCookies(Request query){ StringTokenizer st = … // decode the query while (st.hasMoreTokens()){ … attrs.put(key, value); // populate the map } return attrs; } Map cookies = getCookies(query); String con= cookies.get ("config");

  4. Use Static Analysis for Bloat Detection • Dynamic analysis for bloat detection • Used by all state-of-art tools • “from-symptom-to-cause” diagnosis (heuristics based) • Dependent of specific runs • Many produce false positives • The reports may be hard to interpret • Static information may be helpful to reduce false positives • Programmers’ intentions inherent in the code (instead of heuristics) • Independent of inputs and runs

  5. Our Approach • Step 1: A base static analysis • Automatically extracts container semantics • Based on the context-free-language (CFL) reachability formulation of points-to analysis [Sridharan-Bodik-PLDI’06] • Abstract container operations into ADD and GET • Step 2: Dynamic or static analysis comparing frequencies of ADD and GET • For dynamic analysis: instrument and profile • For static analysis: frequency approximation • Step 3: Inefficiency detection • #ADD is very small  underutilized container • #ADD >> #GET  overpopulated container

  6. CFL-Reachability Formulation Example e a = new A(); // o1 b = new A(); // o2 c = a; ]f c x o1 a [f (1 )1 id(p){ return p;} x = id(a); //call 1y = id(b); //call 2 o3 p ret o4 )2 (2 [f a.f = new C(); //o3 b.f = new C(); //o4 e = x.f; o2 b y o  pts(v) if o flowsTov

  7. Extracting Container Semantics For a container object oc, • Inside objectsand element objects • An ADD is concretized as a store operation that • Writes an element object to a field of an inside object • A GET is concretized as a load operation that • Reads an element object from a field of an inside object

  8. ReachFrom Relation • Relation oreachFromoc • oflowsTo a • b.f = a • bflowsTo ob • obreachFrom oc • A reachFrom path automatically guarantees the context- and field-sensitivity • Demand-driven • Instead of traversing a points-to graph Matched [ ] and ( ) in a reachFrompath (Object[]) ob reachFrom flowsTo [f flowsTo oc o a b (ArrayList) (A)

  9. Detecting Inside and Element Objects • An inside object oiof a container oc is such that • oireachFromoc • oiis created in oc’s class or super class, or other classes specified by the user • An element object oeof a container oc is such that • oeis not an inside object • oereachFromoc • All objects except oe and ocon this reachFrom path are inside objects oe oi … oi… oc Container internal structure

  10. addTo Reachability • An addTo path from an element object oe to a container object oc • oeflowsToa • b.f = a • bflowsTo ob where ob is an inside object • oareachFrom oc : store achieving ADD Matched [ ] and { } in an addTopath (Object[]) ob reachFrom flowsTo [f flowsTo oc o a b addTo (ArrayList) (A)

  11. getFrom Reachability • A getFrom path from an element object oe to container object oc • oeflowsToa • a = b.f • bflowsTo ob where ob is an inside object • obreachFrom oc : load achieving GET Matched [ ] and ( ) in a getFrom path (Object[]) ob reachFrom flowsTo ]f flowsTo oc o a b getFrom (ArrayList) (A)

  12. Relevant Contexts • Identify calling contexts to associate each ADD/GET with a particular container object • The chain of unbalanced method entry/exit edges (1 ( 2 ( 2 … before the store/load (achieving ADD/GET) on each addTo/getFrom path • Details can be found in the paper

  13. Execution Frequency Comparison • Dynamic analysis • Instrument the ADD/GET sites and do frequency profiling • Static analysis: approximation • Based on loop nesting information– inequality graph • Put ADD/GET with relevant contexts onto inequality graph and check the path • Example List l = new List(); while(*) { while(*){ l.add(…); } l.get(…); } while(*){ List l = new List(); l.add(…); l.add(…); } Overpopulated Container #ADD >> #GET Underutilized Container # ADD is small

  14. Evaluation • Implemented based on Soot and the Sridharan-Bodik points-to analysis framework [PLDI’06] • The static analysis is scalable • 19 large apps including eclipse (41k methods, 1623 containers) analyzed • Low false positive rate • For each benchmark, randomly selected 10 container problems for manual check • No FP found for 14 programs • 1-3 FPs found for the remaining 5 apps

  15. Static Analysis vs Dynamic Analysis • Static report is easier to understand and verify • Optimization solutions can be easily seen for most problems reported by static analysis • For most problems reported by dynamic analysis, we could not have solutions • Highly dependent on inputs and runs • Dynamic frequency information can be incorporated for performance tuning • Statically analyze hot containers • Case studies can be found in the paper

  16. Conclusions • The first static analysis targeting bloat detection • Find container inefficiency based on loop nesting • Demand driven and client driven • Unsound but has low false positive rate • Usage • Find container problems during development • Help performance tuning with the help of dynamic frequency info • Static analysis to detect other kinds of bloat?

  17. Thank you

  18. Inefficiency Detection • Mount ADD/GET operations with the relevant contextsonto an inequality graph, and check the inequality edges involved • Example IG for ≤ (2 List l = new List(); for(…){ while(…){ A a = new A(); l.add(a); //call 1 } l.get(i); // call 2 } Object get(int j){ t2 = this3.arr; return t2[j]; } for(…){ List l = new List(); A a = new A(); B b = new B(); l.add(a); //call 1 l.add(b); //call 2 } … void add(Objectx){ t1 = this2.arr; t1 [ind++] = x; } Relevant contexts Relevant contexts IG entry_get while for (2 (1 (1 (1 (2 (2 entry_add entry_add UC: No inequality edge on the IG path between the alloc site of l and the ADD store OC: Inequality edge exits on the IG path from the GET load to the ADD store

  19. Extracting Container Semantics For a container object oc, • Inside objectand element object • An ADD is concretized as a store that • Writes an element object to a field of an inside object • A GET is concretized as a load that • Reads an element object from a field of an inside object • Relation oreachFrom oc Obj  Obj • o flowsTo a • b.f = a • bflowsTo ob • obreachFrom oc Matched [ ] and { } in a reachFrompath

More Related